{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "2a9664f8",
   "metadata": {},
   "source": [
    "# NequIP：基于等变图神经网络的材料性质预测模型（MindSpore 实现）\n",
    "\n",
    "## 模型简介\n",
    "\n",
    "**NequIP（Neural Equivariant Interatomic Potential）** 是一种基于 **E(3)-等变图神经网络（E(3)-Equivariant GNN）** 的分子与材料建模方法。  \n",
    "该模型通过在原子间建立图结构，并在消息传递过程中保持旋转、平移与反射对称性，使得预测结果在三维空间变换下保持一致性。  \n",
    "相比传统的分子势能面模型，NequIP 具备更高的数据效率与物理一致性，能够在少量样本下学习复杂的原子间相互作用。\n",
    "\n",
    "## 模型架构\n",
    "\n",
    "NequIP 的核心由以下部分组成：\n",
    "\n",
    "- **原子特征嵌入（Embedding Layer）**：将原子种类映射到连续特征空间；\n",
    "- **等变消息传递层（Equivariant Message Passing）**：基于径向函数与球谐基展开，实现 E(3) 等变的特征更新；\n",
    "- **能量预测头（Energy/Force Head）**：对每个原子的能量贡献进行汇总，计算体系总能量\n",
    "\n",
    "## 应用场景\n",
    "\n",
    "NequIP 模型适用于多种原子尺度建模任务，包括：\n",
    "\n",
    "- 分子或晶体体系的**能量预测**；\n",
    "- **分子动力学模拟** 中的力场预测；\n",
    "- **材料性质预测**，如结合能、晶格常数、带隙估计等。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "27d5afd4",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/zdai/miniconda3/envs/mindc_py39/lib/python3.9/site-packages/numpy/core/getlimits.py:549: UserWarning: The value of the smallest subnormal for <class 'numpy.float64'> type is zero.\n",
      "  setattr(self, word, getattr(machar, word).flat[0])\n",
      "/home/zdai/miniconda3/envs/mindc_py39/lib/python3.9/site-packages/numpy/core/getlimits.py:89: UserWarning: The value of the smallest subnormal for <class 'numpy.float64'> type is zero.\n",
      "  return self._float_to_str(self.smallest_subnormal)\n",
      "/home/zdai/miniconda3/envs/mindc_py39/lib/python3.9/site-packages/numpy/core/getlimits.py:549: UserWarning: The value of the smallest subnormal for <class 'numpy.float32'> type is zero.\n",
      "  setattr(self, word, getattr(machar, word).flat[0])\n",
      "/home/zdai/miniconda3/envs/mindc_py39/lib/python3.9/site-packages/numpy/core/getlimits.py:89: UserWarning: The value of the smallest subnormal for <class 'numpy.float32'> type is zero.\n",
      "  return self._float_to_str(self.smallest_subnormal)\n"
     ]
    }
   ],
   "source": [
    "import logging\n",
    "import math\n",
    "import os\n",
    "import mindspore as ms\n",
    "from mindspore import Profiler\n",
    "from mindspore import nn\n",
    "from src.dataset import create_training_dataset, _unpack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "edf71a8f",
   "metadata": {},
   "outputs": [],
   "source": [
    "import yaml\n",
    "# 读取配置文件\n",
    "with open(\"./rmd.yaml\", \"r\", encoding=\"utf-8\") as f:\n",
    "    configs = yaml.safe_load(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4141daa5",
   "metadata": {},
   "source": [
    "## 数据集说明：`rmd17_uracil.npz`\n",
    "\n",
    "### 基本信息\n",
    "\n",
    "- **数据集名称**：`rmd17_uracil.npz`\n",
    "- **数据来源**：[Revised MD-17 (RMD-17)](https://figshare.com/articles/dataset/Revised_MD17_dataset_rMD17_/12672038)\n",
    "- **目标分子**：**尿嘧啶（Uracil）**\n",
    "- **数据格式**：`.npz`（NumPy 压缩格式）\n",
    "- **原子数**：每构型 **24 个原子**（含氢）\n",
    "\n",
    "---\n",
    "\n",
    "### 数据内容概览\n",
    "\n",
    "该数据集包含尿嘧啶分子在分子动力学（MD）模拟中的 **原子构型轨迹** 与对应的 **高精度量子力学能量和力**，数据经过修正以解决原始 MD-17 的能量不一致性问题。  \n",
    "\n",
    "所有构型共享相同的原子序数列表（`nuclear_charges`），适用于：\n",
    "\n",
    "- 分子势能面建模\n",
    "- 机器学习力场（MLFF）训练\n",
    "- 图神经网络（GNN）在分子系统上的能量与力联合预测\n",
    "\n",
    "---\n",
    "\n",
    "### 原始字段说明（`.npz` 文件）\n",
    "\n",
    "| 字段名 | 形状 | 类型 | 说明 |\n",
    "|-------|------|------|------|\n",
    "| `nuclear_charges` | `(24,)` | int | 每个原子的原子序数（Z），全局共享，不随构型变化 |\n",
    "| `coords` | `(N, 24, 3)` | float | 所有构型的原子坐标（单位：Å） |\n",
    "| `energies` | `(N,)` | float | 每个构型的标量能量（单位：kcal/mol） |\n",
    "| `forces` | `(N, 24, 3)` | float | 每个原子在每个构型中所受的力（单位：kcal/mol/Å） |\n",
    "\n",
    "---\n",
    "\n",
    "### 模型输入输出结构\n",
    "\n",
    "#### 输入字段\n",
    "\n",
    "| 字段 | 形状 | 说明 |\n",
    "|------|------|------|\n",
    "| `x` | `(B * 24,)` | 原子类型索引（int），由 `nuclear_charges` 映射而来，用于嵌入层 |\n",
    "| `pos` | `(B * 24, 3)` | 展平后的原子坐标 |\n",
    "| `edge_index` | `(2, num_edges)` | 通过 `radius_graph_full` 构建的边索引（由 `pos` 动态生成） |\n",
    "| `batch` | `(B * 24,)` | 批次索引，用于区分不同构型 |\n",
    "\n",
    "#### 输出目标（`label` → `energy`）\n",
    "\n",
    "| 字段 | 形状 | 说明 |\n",
    "|------|------|------|\n",
    "| `energy` | `(B, 1)` | 归一化后的能量标签 |\n",
    "\n",
    "---\n",
    "\n",
    "### 自定义数据集\n",
    "\n",
    "如果想自定义数据集，需要保证包含以下字段：\n",
    "\n",
    "```json\n",
    "{\n",
    "  \"nuclear_charges\": [6, 7, 8, 1, ...],\n",
    "  \"coords\": [[[x, y, z], ...], ...],\n",
    "  \"energies\": [...]\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "d0af49e8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "数据集加载完成\n",
      "训练样本数: 950, 验证样本数: 50\n"
     ]
    }
   ],
   "source": [
    "from src.dataset import create_training_dataset\n",
    "\n",
    "data_params = configs.get('data')\n",
    "trainset, train_edge_index, train_batch, evalset, eval_edge_index, eval_batch, num_type = create_training_dataset(\n",
    "    config=data_params,\n",
    "    dtype=ms.float32,\n",
    "    pred_force=configs.get('pred_force')\n",
    ")\n",
    "\n",
    "print(\"数据集加载完成\")\n",
    "print(f\"训练样本数: {data_params.get('n_train')}, 验证样本数: {data_params.get('n_val')}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2bd0326c",
   "metadata": {},
   "source": [
    "NequIP 模型训练流程"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c9ba202b",
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import logging\n",
    "from mindspore import nn, Profiler\n",
    "from src.dataset import _unpack\n",
    "from mindchemistry.cell import Nequip\n",
    "from tqdm.notebook import tqdm\n",
    "\n",
    "def generate_learning_rate(learning_rate, warmup_steps, step_num):\n",
    "    warmup_scale = warmup_steps ** -1.5\n",
    "    lr = []\n",
    "    for s in range(1, step_num + 1):\n",
    "        lr1 = s ** -0.5\n",
    "        lr2 = s * warmup_scale\n",
    "        lr.append(learning_rate * min(lr1, lr2))\n",
    "    return lr\n",
    "\n",
    "def train(dtype=ms.float32, configs=None):\n",
    "    \"\"\"NequIP 模型训练流程\"\"\"\n",
    "    data_params = configs.get('data')\n",
    "    model_params = configs.get('model')\n",
    "    optimizer_params = configs.get('optimizer')\n",
    "    pred_force = configs.get('pred_force')\n",
    "    is_profiling = configs.get('profiling')\n",
    "    enable_mix_precision = configs.get('enable_mix_precision')\n",
    "    ncon_dtype = ms.float16 if enable_mix_precision else ms.float32\n",
    "\n",
    "    load_ckpt = configs.get('load_ckpt')\n",
    "    load_ckpt_path = configs.get('load_ckpt_path')\n",
    "    save_ckpt = configs.get('save_ckpt')\n",
    "    save_ckpt_interval = configs.get('save_ckpt_interval')\n",
    "    save_ckpt_path = configs.get('save_ckpt_path')\n",
    "    if save_ckpt:\n",
    "        os.makedirs(save_ckpt_path, exist_ok=True)\n",
    "\n",
    "    logging.info('Loading data...')\n",
    "    trainset, train_edge_index, train_batch, evalset, eval_edge_index, eval_batch, num_type = create_training_dataset(\n",
    "        config=data_params, dtype=dtype, pred_force=configs.get('pred_force'))\n",
    "\n",
    "    # ===== 模型初始化 =====\n",
    "    logging.info('Initializing model...')\n",
    "    net = Nequip(\n",
    "        irreps_embedding_out=model_params.get('irreps_embedding_out'),\n",
    "        irreps_conv_out=model_params.get('irreps_conv_out'),\n",
    "        chemical_embedding_irreps_out=model_params.get('chemical_embedding_irreps_out'),\n",
    "        num_layers=model_params.get('num_layers'),\n",
    "        num_type=num_type,\n",
    "        r_max=model_params.get('r_max'),\n",
    "        hidden_mul=model_params.get('hidden_mul'),\n",
    "        pred_force=pred_force,\n",
    "        dtype=dtype,\n",
    "        ncon_dtype=ncon_dtype\n",
    "    )\n",
    "\n",
    "    if load_ckpt:\n",
    "        logging.info('Loading checkpoint: %s', load_ckpt_path)\n",
    "        ms.load_checkpoint(load_ckpt_path, net)\n",
    "\n",
    "    loss_fn = nn.MSELoss()\n",
    "    metric_fn = nn.MAELoss()\n",
    "    total_steps_num = optimizer_params.get('num_epoch') * math.ceil(\n",
    "        data_params.get('n_train') / data_params.get('batch_size'))\n",
    "    lr_schedule = generate_learning_rate(\n",
    "        optimizer_params.get('learning_rate'),\n",
    "        optimizer_params.get('warmup_steps'),\n",
    "        total_steps_num\n",
    "    )\n",
    "    optimizer = nn.Adam(net.trainable_params(), learning_rate=lr_schedule,\n",
    "                        use_amsgrad=optimizer_params.get('use_amsgrad'))\n",
    "\n",
    "    # === 前向计算 ===\n",
    "    def forward(batch, x, pos, edge_src, edge_dst, energy, force, batch_size, sep):\n",
    "        pred = net(batch, x, pos, edge_src, edge_dst, batch_size)\n",
    "        if pred_force:\n",
    "            loss_energy = loss_fn(pred[0], energy)\n",
    "            loss_force = loss_fn(pred[1], force)\n",
    "            return loss_energy + 1000. * loss_force\n",
    "        return loss_fn(pred, energy)\n",
    "\n",
    "    backward = ms.value_and_grad(forward, None, optimizer.parameters)\n",
    "\n",
    "\n",
    "    def train_step(batch, x, pos, edge_src, edge_dst, energy, force, size, sep):\n",
    "        loss_, grads_ = backward(batch, x, pos, edge_src, edge_dst, energy, force, size, sep)\n",
    "        optimizer(grads_)\n",
    "        return loss_\n",
    "\n",
    "    # === 验证 ===\n",
    "    def validation(eval_batch, eval_edge_index, evalset):\n",
    "        dataset_size = evalset.get_dataset_size()\n",
    "        total_eval, total_metric = 0, 0\n",
    "        for _, data_dict_val in enumerate(evalset.create_dict_iterator()):\n",
    "            batch_size_val = evalset.get_batch_size()\n",
    "            inputs_val, label_val = _unpack(data_dict_val)\n",
    "            pred = net(eval_batch, inputs_val[0], inputs_val[1],\n",
    "                       eval_edge_index[0], eval_edge_index[1], batch_size_val)\n",
    "            loss_val = loss_fn(pred, label_val[0]).asnumpy()\n",
    "            metric = metric_fn(pred, label_val[0]).asnumpy()\n",
    "            total_eval += loss_val\n",
    "            total_metric += metric\n",
    "        loss = total_eval / dataset_size\n",
    "        metric_mean = total_metric / dataset_size\n",
    "        logging.info('Eval loss: %8.8f   metric: %.8f', loss, metric_mean)\n",
    "        return loss, metric_mean\n",
    "\n",
    "    # === 开始训练 ===\n",
    "    if is_profiling:\n",
    "        profiler = Profiler(output_path=\"profiler_data\")\n",
    "\n",
    "    loss_train, loss_eval, metric = [], [], []\n",
    "    eval_steps = optimizer_params.get('eval_steps')\n",
    "\n",
    "    for epoch in range(optimizer_params.get('num_epoch')):\n",
    "        epoch_loss = 0\n",
    "        pbar = tqdm(\n",
    "        total=trainset.get_dataset_size(),\n",
    "        desc=f\"Epoch {epoch+1}/{optimizer_params.get('num_epoch')}\",\n",
    "        leave=True  # 不覆盖\n",
    "        )\n",
    "        for _, data_dict in enumerate(trainset.create_dict_iterator()):\n",
    "            inputs, label = _unpack(data_dict)\n",
    "            batch_size_train = trainset.get_batch_size()\n",
    "            loss = train_step(train_batch, inputs[0], inputs[1],\n",
    "                              train_edge_index[0], train_edge_index[1],\n",
    "                              label[0], label[1], batch_size_train, False)\n",
    "            epoch_loss += loss.asnumpy()\n",
    "            pbar.update(1)\n",
    "        pbar.close()\n",
    "        epoch_loss = epoch_loss / trainset.get_dataset_size()\n",
    "        loss_train.append(epoch_loss)\n",
    "\n",
    "        if (epoch + 1) % eval_steps == 0:\n",
    "            loss_val, metric_val = validation(eval_batch, eval_edge_index, evalset)\n",
    "            loss_eval.append(loss_val)\n",
    "            metric.append(metric_val)\n",
    "\n",
    "        if save_ckpt and (epoch + 1) % save_ckpt_interval == 0:\n",
    "            ms.save_checkpoint(net, f\"{save_ckpt_path}/NequIP_rmd_{epoch}.ckpt\")\n",
    "\n",
    "    if is_profiling:\n",
    "        profiler.analyse()\n",
    "    if save_ckpt:\n",
    "        ms.save_checkpoint(net, f\"{save_ckpt_path}/NequIP_rmd.ckpt\")\n",
    "\n",
    "    print(f\"训练完成，共 {optimizer_params.get('num_epoch')} 个 epoch\")\n",
    "    return loss_train, loss_eval, metric, lr_schedule"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "a998db9f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c5da6ca2f23047ceb1b9ad26723dc0ca",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epoch 1/2:   0%|          | 0/190 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "......."
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8d458ccb5cfd4b0384776db5cd33e593",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epoch 2/2:   0%|          | 0/190 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "训练完成，共 2 个 epoch\n"
     ]
    }
   ],
   "source": [
    "loss_train, loss_eval, metric, lr_schedule = train(dtype=ms.float32, configs=configs)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "6c82ce40",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.figure(figsize=(6,4))\n",
    "plt.plot(loss_train, label=\"Train Loss\")\n",
    "plt.title(\"Training Loss Curve\")\n",
    "plt.xlabel(\"Epoch\")\n",
    "plt.ylabel(\"Loss\")\n",
    "plt.legend()\n",
    "plt.grid(True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a23ca09",
   "metadata": {},
   "source": [
    "predict定义"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "07bf6541",
   "metadata": {},
   "outputs": [],
   "source": [
    "import traceback\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "def evaluation_safe(dtype, configs):\n",
    "    \"\"\"\n",
    "    Robust evaluation wrapper for notebook use.\n",
    "    Returns: (pred_list, loss_mean, metric_mean) or (None, None, None) on error.\n",
    "    Prints diagnostic info and full traceback on exceptions.\n",
    "    \"\"\"\n",
    "    try:\n",
    "        # ---- basic checks ----\n",
    "        if configs is None:\n",
    "            print(\"[ERROR] configs is None\")\n",
    "            return None, None, None\n",
    "        data_params = configs.get('data', {})\n",
    "        model_params = configs.get('model', {})\n",
    "        pred_force = configs.get('pred_force', False)\n",
    "        load_ckpt_path = configs.get('load_ckpt_path')\n",
    "        save_path = data_params.get('save_path', \"./pred_results\")\n",
    "        os.makedirs(save_path, exist_ok=True)\n",
    "\n",
    "        print(\"[INFO] dtype:\", dtype)\n",
    "        print(\"[INFO] load_ckpt_path:\", load_ckpt_path)\n",
    "        if load_ckpt_path is None or not os.path.exists(load_ckpt_path):\n",
    "            print(f\"[ERROR] checkpoint not found at: {load_ckpt_path}\")\n",
    "            print(\"-> please set configs['load_ckpt_path'] to a valid .ckpt file path\")\n",
    "            return None, None, None\n",
    "\n",
    "        # ---- load evaluation dataset ----\n",
    "        print(\"[INFO] Creating evaluation dataset...\")\n",
    "        _, _, _, evalset, eval_edge_index, eval_batch, num_type = create_training_dataset(\n",
    "            config=data_params, dtype=dtype, pred_force=pred_force)\n",
    "\n",
    "        print(\"[INFO] Eval dataset size:\", evalset.get_dataset_size())\n",
    "        print(\"[INFO] Eval batch size:\", evalset.get_batch_size())\n",
    "        print(\"[INFO] num_type:\", num_type)\n",
    "\n",
    "        # ---- build model ----\n",
    "        print(\"[INFO] Initializing model...\")\n",
    "        net = Nequip(\n",
    "            irreps_embedding_out=model_params.get('irreps_embedding_out'),\n",
    "            irreps_conv_out=model_params.get('irreps_conv_out'),\n",
    "            chemical_embedding_irreps_out=model_params.get('chemical_embedding_irreps_out'),\n",
    "            num_layers=model_params.get('num_layers'),\n",
    "            num_type=num_type,\n",
    "            r_max=model_params.get('r_max'),\n",
    "            hidden_mul=model_params.get('hidden_mul'),\n",
    "            pred_force=pred_force,\n",
    "            dtype=dtype,\n",
    "        )\n",
    "\n",
    "        # ---- load checkpoint ----\n",
    "        try:\n",
    "            print(f\"[INFO] Loading checkpoint from {load_ckpt_path} ...\")\n",
    "            ms.load_checkpoint(load_ckpt_path, net)\n",
    "            print(\"[INFO] Checkpoint loaded successfully.\")\n",
    "        except Exception as e_ckpt:\n",
    "            print(\"[ERROR] Failed to load checkpoint:\",e_ckpt)\n",
    "            traceback.print_exc()\n",
    "            return None, None, None\n",
    "\n",
    "        loss_fn = nn.MSELoss()\n",
    "        metric_fn = nn.MAELoss()\n",
    "\n",
    "        # ---- evaluation loop ----\n",
    "        dataset_size = evalset.get_dataset_size()\n",
    "        print(\"[INFO] Starting evaluation loop...\")\n",
    "        total_loss = total_metric = 0.0\n",
    "        total_loss_energy = total_loss_force = 0.0\n",
    "        total_metric_energy = total_metric_force = 0.0\n",
    "\n",
    "        pred_list = []\n",
    "        pred_energy_list = []\n",
    "        pred_force_list=[]\n",
    "        true_energy_list, true_list = [], []\n",
    "\n",
    "        for idx, data_dict_val in enumerate(evalset.create_dict_iterator()):\n",
    "            try:\n",
    "                batch_size_val = evalset.get_batch_size()\n",
    "                inputs_val, label_val = _unpack(data_dict_val)\n",
    "\n",
    "                # Forward (ensure shapes / types)\n",
    "                pred = net(eval_batch, inputs_val[0], inputs_val[1],\n",
    "                           eval_edge_index[0], eval_edge_index[1], batch_size_val)\n",
    "\n",
    "                if not pred_force:\n",
    "                    loss = loss_fn(pred, label_val[0]).asnumpy()\n",
    "                    metric = metric_fn(pred, label_val[0]).asnumpy()\n",
    "                    total_loss += float(loss)\n",
    "                    total_metric += float(metric)\n",
    "                    pred_list.append(pred.asnumpy())\n",
    "                    true_list.append(label_val[0].asnumpy())\n",
    "                else:\n",
    "                    loss_energy = float(loss_fn(pred[0], label_val[0]).asnumpy())\n",
    "                    loss_force = float(loss_fn(pred[1], label_val[1]).asnumpy())\n",
    "                    metric_energy = float(metric_fn(pred[0], label_val[0]).asnumpy())\n",
    "                    metric_force = float(metric_fn(pred[1], label_val[1]).asnumpy())\n",
    "                    total_loss_energy += loss_energy\n",
    "                    total_loss_force += loss_force\n",
    "                    total_metric_energy += metric_energy\n",
    "                    total_metric_force += metric_force\n",
    "                    pred_energy_list.append(pred[0].asnumpy())\n",
    "                    pred_force_list.append(pred[1].asnumpy())\n",
    "                    true_energy_list.append(label_val[0].asnumpy())\n",
    "            except Exception as e_batch:\n",
    "                print(f\"[ERROR] Exception during eval loop at batch {idx}:\",e_batch)\n",
    "                traceback.print_exc()\n",
    "                # continue to next batch (or return depending on your preference)\n",
    "                return None, None, None\n",
    "        print(\"pred_list: \", pred_list)\n",
    "        # ---- summarize and save ----\n",
    "        if not pred_force:\n",
    "            loss_mean = total_loss / dataset_size\n",
    "            metric_mean = total_metric / dataset_size\n",
    "            np.save(os.path.join(save_path, configs[\"data\"][\"pred_file\"]), pred_list)\n",
    "            np.save(os.path.join(save_path, configs[\"data\"][\"true_file\"]), true_list)\n",
    "            print(\"[INFO] Predictions and true values saved to:\", save_path)\n",
    "            print(f\"[RESULT] loss_mean: {loss_mean:.8f}  metric_mean: {metric_mean:.8f}\")\n",
    "            return pred_list, loss_mean, metric_mean\n",
    "        loss_mean = (total_loss_energy / dataset_size, total_loss_force / dataset_size)\n",
    "        metric_mean = (total_metric_energy / dataset_size, total_metric_force / dataset_size)\n",
    "        np.save(os.path.join(save_path, configs[\"data\"][\"pred_energy_file\"]), pred_energy_list)\n",
    "        np.save(os.path.join(save_path, configs[\"data\"][\"true_energy_file\"]), true_energy_list)\n",
    "        print(f\"[RESULT] loss_energy_mean: {loss_mean[0]:.8f}  loss_force_mean: {loss_mean[1]:.8f}\")\n",
    "        print(f\"[RESULT] metric_energy_mean: {metric_mean[0]:.8f}  metric_force_mean: {metric_mean[1]:.8f}\")\n",
    "        return [pred_energy_list, pred_force_list], loss_mean, metric_mean\n",
    "\n",
    "    except Exception as e:\n",
    "        print(\"[FATAL] Unexpected exception in evaluation_safe:\",e)\n",
    "        traceback.print_exc()\n",
    "        return None, None, None\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "d5f4d14b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] dtype: Float32\n",
      "[INFO] load_ckpt_path: ./checkpoints/NequIP_rmd.ckpt\n",
      "[INFO] Creating evaluation dataset...\n",
      "[INFO] Eval dataset size: 10\n",
      "[INFO] Eval batch size: 5\n",
      "[INFO] num_type: 4\n",
      "[INFO] Initializing model...\n",
      "[INFO] Loading checkpoint from ./checkpoints/NequIP_rmd.ckpt ...\n",
      "[INFO] Checkpoint loaded successfully.\n",
      "[INFO] Starting evaluation loop...\n",
      "pred_list:  [array([[0.01096156],\n",
      "       [0.01152362],\n",
      "       [0.0088922 ],\n",
      "       [0.00950281],\n",
      "       [0.00832928]], dtype=float32), array([[0.00859195],\n",
      "       [0.0075928 ],\n",
      "       [0.00821682],\n",
      "       [0.0109686 ],\n",
      "       [0.00735036]], dtype=float32), array([[0.01072004],\n",
      "       [0.00882988],\n",
      "       [0.00881849],\n",
      "       [0.00874564],\n",
      "       [0.01059538]], dtype=float32), array([[0.00778127],\n",
      "       [0.00994838],\n",
      "       [0.00931875],\n",
      "       [0.0101115 ],\n",
      "       [0.01051393]], dtype=float32), array([[0.00808171],\n",
      "       [0.00788514],\n",
      "       [0.00946121],\n",
      "       [0.00925998],\n",
      "       [0.01006626]], dtype=float32), array([[0.00661376],\n",
      "       [0.00876329],\n",
      "       [0.00891308],\n",
      "       [0.00958218],\n",
      "       [0.00865374]], dtype=float32), array([[0.00685227],\n",
      "       [0.00931741],\n",
      "       [0.00876838],\n",
      "       [0.01059075],\n",
      "       [0.00979946]], dtype=float32), array([[0.00971784],\n",
      "       [0.010439  ],\n",
      "       [0.00853684],\n",
      "       [0.01099091],\n",
      "       [0.00990788]], dtype=float32), array([[0.00750377],\n",
      "       [0.01113972],\n",
      "       [0.01076543],\n",
      "       [0.00947448],\n",
      "       [0.0092768 ]], dtype=float32), array([[0.00842626],\n",
      "       [0.00970375],\n",
      "       [0.0102906 ],\n",
      "       [0.00866342],\n",
      "       [0.00942835]], dtype=float32)]\n",
      "[INFO] Predictions and true values saved to: ./results\n",
      "[RESULT] loss_mean: 0.02837591  metric_mean: 0.13121371\n",
      "Returned: True 0.02837591350544244 0.1312137119472027\n"
     ]
    }
   ],
   "source": [
    "pred_list, loss_mean, metric_mean = evaluation_safe(ms.float32, configs)\n",
    "print(\"Returned:\", pred_list is not None, loss_mean, metric_mean)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "a8cd2e7f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 训练epoch达到200个epoch之后，下图的绘制才会有显著效果，这里采用较小的epoch是为了快速验证\n",
    "import matplotlib.pyplot as plt\n",
    "pred_energy = np.load(\"./results/pred.npy\", allow_pickle=True)\n",
    "true_energy = np.load(\"./results/true.npy\", allow_pickle=True)\n",
    "# 绘制能量对比图\n",
    "plt.figure(figsize=(10, 5))\n",
    "num_batches_to_show = min(5, len(pred_energy))  # 只展示前5个batch\n",
    "\n",
    "for i in range(num_batches_to_show):\n",
    "    plt.plot(true_energy[i][:50], label=f\"True Batch {i}\")\n",
    "    plt.plot(pred_energy[i][:50], \"--\", label=f\"Pred Batch {i}\")\n",
    "\n",
    "plt.title(\"Energy Prediction Comparison (First Few Batches)\")\n",
    "plt.xlabel(\"Sample Index in Batch\")\n",
    "plt.ylabel(\"Energy\")\n",
    "plt.legend(ncol=2, fontsize=8)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "46bf15c2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'pred_force': False, 'profiling': False, 'load_ckpt': False, 'load_ckpt_path': './checkpoints/NequIP_rmd.ckpt', 'save_ckpt': True, 'save_ckpt_interval': 200, 'save_ckpt_path': './checkpoints', 'enable_mix_precision': False, 'model': {'irreps_embedding_out': '16x0e', 'irreps_conv_out': '64x0o+64x0e+64x1o+64x1e+64x2o+64x2e', 'chemical_embedding_irreps_out': '64x0e', 'num_layers': 5, 'num_type': 4, 'r_max': 4, 'hidden_mul': 64}, 'optimizer': {'num_epoch': 2, 'eval_steps': 10, 'warmup_steps': 6400, 'learning_rate': 0.01, 'use_amsgrad': True}, 'data': {'name': 'nequip', 'path': './dataset/MD17/npz_data/rmd17_uracil.npz', 'save_path': './results', 'n_train': 950, 'n_val': 50, 'batch_size': 5, 'save_pred': True, 'save_true': True, 'pred_file': 'pred.npy', 'true_file': 'true.npy'}}\n",
      "./dataset/MD17/npz_data/rmd17_uracil.npz\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABeQAAAH4CAYAAAArY+2bAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8ekN5oAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3xUVfrH8c+dVAIpJCShhlBD7wgoIk0CuyAdFZEiIkpTBLH8RBRUipRFQVRUygKKNEWKSEcEdkGKgIL0HiAJaSSkzf39kc3ImAABkwxJvm9fZ5e559w7z51AZu4z5z7HME3TREREREREREREREREcpTF0QGIiIiIiIiIiIiIiBQESsiLiIiIiIiIiIiIiOQCJeRFRERERERERERERHKBEvIiIiIiIiIiIiIiIrlACXkRERERERERERERkVyghLyIiIiIiIiIiIiISC5QQl5EREREREREREREJBcoIS8iIiIiIiIiIiIikguUkBcRERERERERERERyQVKyIuIiIiI/A2GYfD22287OgwREREREckDlJAXEREREYc7ePAg3bp1o2zZsri7u1OqVCkeffRRPvroI0eHlut+/PFH+vfvT40aNXByciI4ONjRIYmIiIiISDZRQl5EREREHGrHjh00aNCAAwcOMGDAAGbMmMGzzz6LxWJh+vTpjg4v1y1atIhFixbh7e1NyZIlHR2OiIiIiIhkI2dHByAiIiIiBdt7772Ht7c3u3fvxsfHx67vypUrjgnKgd5//31mz56Ni4sL7du359ChQ44OSUREREREsolmyIuIiIiIQ504cYLq1atnSMYDBAQE2D2eM2cOLVu2JCAgADc3N6pVq8asWbMy7BccHEz79u3ZsmULDRo0oFChQtSsWZMtW7YAsHz5cmrWrIm7uzv169dn3759dvv37duXIkWKcPLkSUJDQylcuDAlS5Zk7NixmKZ5x3O6cOECzzzzDIGBgbi5uVG9enW+/PLLLL0eJUuWxMXFJUtjRUREREQkb1FCXkREREQcqmzZsvzyyy9Zmgk+a9YsypYtyxtvvMGUKVMoU6YMgwYNYubMmRnGHj9+nJ49e9KhQwfGjx/PtWvX6NChAwsXLmT48OH06tWLd955hxMnTtCjRw+sVqvd/qmpqbRt25bAwEAmTZpE/fr1GTNmDGPGjLltjJcvX6Zx48Zs2LCBIUOGMH36dCpWrEj//v3517/+dVevjYiIiIiI5C+GmZUpPiIiIiIiOWT9+vW0a9cOgAceeICHH36YVq1a0aJFiwwzxRMSEihUqJDdtrZt23Ls2DFOnDhh2xYcHMyZM2fYsWMHTZo0AdIWSw0NDaVQoUIcOXKEoKAgAD777DMGDhzI5s2bad68OZA2Q37evHkMHTqUDz/8EADTNOnQoQPr16/nwoULFCtWDADDMBgzZgxvv/02AM8++yxr1qzh4MGD+Pn52WJ68sknWbt2LZcuXcpwDreSXrLm9OnTWRovIiIiIiL3N82QFxERERGHevTRR9m5cyePPfYYBw4cYNKkSYSGhlKqVClWrlxpN/bmRHZ0dDTh4eE88sgjnDx5kujoaLux1apVsyXjARo1agRAy5Ytbcn4m7efPHkyQ2xDhgyx/dkwDIYMGUJSUhIbNmzI9FxM02TZsmV06NAB0zQJDw+3tdDQUKKjo9m7d29WXxoREREREclntKiriIiIiDhcw4YNWb58OUlJSRw4cIAVK1Ywbdo0unXrxv79+6lWrRoAP//8M2PGjGHnzp3Ex8fbHSM6Ohpvb2/b45uT7oCtr0yZMpluv3btmt12i8VC+fLl7bZVrlwZ4JYz1q9evUpUVBSfffYZn332WaZjCuJCtSIiIiIikkYJeRERERG5b7i6utKwYUMaNmxI5cqV6devH0uWLGHMmDGcOHGCVq1aUaVKFaZOnUqZMmVwdXVlzZo1TJs2LUMNeCcnp0yf41bbs6OSY3oMvXr1ok+fPpmOqVWr1t9+HhERERERyZuUkBcRERGR+1KDBg0AuHTpEgDff/89iYmJrFy50m72++bNm3Pk+a1WKydPnrTNigf4448/gLQa9Znx9/fH09OT1NRUWrdunSNxiYiIiIhI3qUa8iIiIiLiUJs3b850dvqaNWsACAkJAf6c2X7z2OjoaObMmZNjsc2YMcP2Z9M0mTFjBi4uLrRq1SrT8U5OTnTt2pVly5Zx6NChDP1Xr17NsVhFREREROT+pxnyIiIiIuJQQ4cOJT4+ns6dO1OlShWSkpLYsWMHixcvJjg4mH79+gHQpk0bXF1d6dChAwMHDiQuLo7Zs2cTEBBgm0Wfndzd3fnhhx/o06cPjRo1Yu3ataxevZo33ngDf3//W+43YcIENm/eTKNGjRgwYADVqlUjMjKSvXv3smHDBiIjI2/7vL/++qttMdvjx48THR3Nu+++C0Dt2rXp0KFD9p2kiIhIDjEMgzFjxvD22287OhQRkfuKEvIiIiIi4lCTJ09myZIlrFmzhs8++4ykpCSCgoIYNGgQb775Jj4+PkDaTPmlS5fy5ptvMnLkSIoXL84LL7yAv78/zzzzTLbH5eTkxA8//MALL7zAK6+8gqenJ2PGjOGtt9667X6BgYH897//ZezYsSxfvpyPP/4YPz8/qlevzsSJE+/4vHv37mX06NF229If9+nTRwl5EZEC5ODBg7zzzjvs3r2by5cv4+fnR7Vq1XjssccYOnSoo8PLNfHx8cyZM4fvvvuOgwcPEhcXR8WKFXnuued47rnnbrk+jIjcmxs3bpCUlJQjx3Z1dcXd3T1Hjp1XGGZ2rF4lIiIiIpKP9O3bl6VLlxIXF+foUEREpIDasWMHLVq0ICgoiD59+lC8eHHOnTvHrl27OHHiBMePH3d0iLeVnTPkDx06RK1atWjVqhVt2rTBy8uLdevWsWLFCnr37s28efP+fsAiAqQl4/0KeRBPzqSMixcvzqlTpwp0Ul4z5EVERERERERE7jPvvfce3t7e7N6923a3WLorV644JigHKV68OAcPHqR69eq2bQMHDuSZZ55hzpw5jB49mooVKzowQpH8IykpiXhMnqIwrhjZe2xMFoaFkZSUVKAT8lrUVURERERERETkPnPixAmqV6+eIRkPEBAQYPd4zpw5tGzZkoCAANzc3KhWrRqzZs3KsF9wcDDt27dny5YtNGjQgEKFClGzZk22bNkCwPLly6lZsybu7u7Ur1+fffv22e3ft29fihQpwsmTJwkNDaVw4cKULFmSsWPHZrpA+19duHCBZ555hsDAQNzc3KhevTpffvnlHfcrVqyYXTI+XefOnQH4/fff73gMEbk77hg50kQJeRERERERERGR+07ZsmX55ZdfOHTo0B3Hzpo1i7Jly/LGG28wZcoUypQpw6BBg5g5c2aGscePH6dnz5506NCB8ePHc+3aNTp06MDChQsZPnw4vXr14p133uHEiRP06NEDq9Vqt39qaipt27YlMDCQSZMmUb9+fcaMGcOYMWNuG+Ply5dp3LgxGzZsYMiQIUyfPp2KFSvSv39//vWvf93Va5MuLCwMSEvYi0j2smBgMbK5KSEPqIa8iIiIiIiIiMh9Z/369bRr1w6ABx54gIcffphWrVrRokULXFxc7MYmJCRQqFAhu21t27bl2LFjnDhxwrYtODiYM2fOsGPHDpo0aQLAjz/+SGhoKIUKFeLIkSMEBQUB8NlnnzFw4EA2b95M8+bNgbQZ8vPmzWPo0KF8+OGHAJimSYcOHVi/fj0XLlywJcf/WkP+2WefZc2aNRw8eBA/Pz9bTE8++SRr167l0qVLGc7hdpKSkqhbty4JCQn88ccfODurKrNIdoiJicHb25sBeOJqZHPJGtNkNrFER0fj5eWVrcfOSzRDXkRERERERETkPvPoo4+yc+dOHnvsMQ4cOMCkSZMIDQ2lVKlSrFy50m7szYns6OhowsPDeeSRRzh58iTR0dF2Y6tVq2ZLxgM0atQIgJYtW9qS8TdvP3nyZIbYhgwZYvuzYRgMGTKEpKQkNmzYkOm5mKbJsmXL6NChA6ZpEh4ebmuhoaFER0ezd+/erL40thh+++03ZsyYoWS8SA6w5FATLeoqIiIiIiIiInJfatiwIcuXLycpKYkDBw6wYsUKpk2bRrdu3di/fz/VqlUD4Oeff2bMmDHs3LmT+Ph4u2NER0fj7e1te3xz0h2w9ZUpUybT7deuXbPbbrFYKF++vN22ypUrA3D69OlMz+Pq1atERUXx2Wef8dlnn2U65m4Wqv3ggw+YPXs248aN4x//+EeW9xMRuR8oIS8iIiIiIiIich9zdXWlYcOGNGzYkMqVK9OvXz+WLFnCmDFjOHHiBK1ataJKlSpMnTqVMmXK4Orqypo1a5g2bVqGGvBOTk6ZPsettmdHpeP0GHr16kWfPn0yHVOrVq0sHWvu3Lm8+uqrPP/887z55pt/OzYRyZxhgCWbS74bACqerjsFRERERPKjuXPnYhjGLduuXbscHeJ9Yfny5Tz++OOUL18eDw8PQkJCGDFiBFFRURnGBgcHZ/paPv/88xnGrl+/nqZNm+Lh4UHRokXp1q1bprMGb9y4wfjx46lWrRoeHh6UKlWK7t27c/jwYbtxly5d4rXXXqNFixZ4enpiGAZbtmzJcLz4+HhmzpxJmzZtKFGiBJ6entStW5dZs2aRmpqapdckq+fZvHnzW/79+mttYxERyT4NGjQA0t4bAL7//nsSExNZuXIlAwcO5B//+AetW7e+q3rsd8NqtWYoY/PHH38Aae8hmfH398fT05PU1FRat26daQsICLjjc3/33Xc8++yzdOnSJdMFa0VE8gLNkBcRERHJx8aOHUu5cuUybK9YsaIDorn/PPfcc5QsWZJevXoRFBTEwYMHmTFjBmvWrGHv3r0Zkhl16tRhxIgRdtvSb9NPt2rVKjp27Ei9evWYMGECMTExTJ8+naZNm7Jv3z78/f1tY5966ilWrlzJgAEDqFevHhcvXmTmzJk0adKEgwcPUrZsWQCOHj3KxIkTqVSpEjVr1mTnzp2Zns/JkycZOnQorVq14uWXX8bLy4t169YxaNAgdu3axbx587L0umTlPP/v//6PZ5991m7b9evXef7552nTpk2WnkdERG4tfTFV4y+LKq5ZswaAkJAQ4M+Z7TfPZI+OjmbOnDk5FtuMGTPsFnWdMWMGLi4utGrVKtPxTk5OdO3alUWLFnHo0CFq1Khh13/16lW798fMbNu2jSeeeIJmzZqxcOFCLBbNMRXJSTlR813/atMoIS8iIiKSj7Vr1842k86Rrl+/TuHChR0dRgZLly6lefPmdtvq169Pnz59WLhwYYaEc6lSpejVq9dtj/nqq69Svnx5fv75Z1xdXQHo0KGDLUE/ZcoUAC5cuMDy5csZOXIkH3zwgW3/hx9+mJYtW7J8+XKGDx9uiykiIgJfX1+WLl1K9+7dM33u4sWLc/DgQapXr27bNnDgQJ555hnmzJnD6NGjs/RlTFbO89FHH82wbcGCBUDaFw0iIvL3DB06lPj4eDp37kyVKlVISkpix44dLF68mODgYPr16wdAmzZtcHV1pUOHDgwcOJC4uDhmz55NQECAbRZ9dnJ3d+eHH36gT58+NGrUiLVr17J69WreeOON2ybVJ0yYwObNm2nUqBEDBgygWrVqREZGsnfvXjZs2EBkZOQt9z1z5gyPPfYYhmHQrVs3lixZYtdfq1atLJe8ERFxNH0xISIiIlKAnT59GsMwmDx5Mp999hkVKlTAzc2Nhg0bsnv37gzjjxw5Qrdu3fD19cXd3Z0GDRqwcuVKuzHp5XK2bt3KoEGDCAgIoHTp0rb+mTNnUr58eQoVKsQDDzzATz/9RPPmzW2J8bi4OAoXLsyLL76Y4fnPnz+Pk5MT48ePJzk5mSNHjvytZMNfk/EAnTt3BuD333/PdJ+kpCSuX7+eaV9kZCS//fYbnTt3tiXjAWrXrk3VqlX5+uuvbdtiY2MBCAwMtDtGiRIlAOxm53t6euLr63vH8ylWrJhdMj6r55SZ253nrSxatIjChQvTsWPHu9pPREQymjx5Mi1atGDNmjW8/PLLvPzyy/z3v/9l0KBB/Oc//8HHxwdImym/dOlSDMNg5MiRfPLJJzz33HOZvo9mBycnJ3744QfCwsJ45ZVX2L17N2PGjGHcuHG33S8wMJD//ve/9OvXj+XLlzNkyBCmT59OZGQkEydOvO2+p06dIjo6moSEBAYPHszTTz9t15YvX56dpygigMUwcqSJZsiLiIiI5GvR0dGEh4fbbTMMAz8/P7ttixYtIjY2loEDB2IYBpMmTaJLly6cPHnSVg/88OHDPPTQQ5QqVYrXXnuNwoUL880339CpUyeWLVtmS/qmGzRoEP7+/rz11lu2xO6sWbMYMmQIDz/8MMOHD+f06dN06tSJokWL2pL2RYoUoXPnzixevJipU6faLTL31VdfYZomTz31FBcuXKBq1ar06dOHuXPnZttrFhYWBqQlt/9q06ZNeHh4kJqaStmyZRk+fLhdwiMxMREg07q9Hh4eHD58mLCwMIoXL06FChUoXbo0U6ZMISQkhLp163Lx4kVGjRpFuXLleOKJJ3LlnDJzp/PMzNWrV1m/fj2PP/74fXk3hIhIXtO2bVvatm2bpbEdOnSgQ4cOGbanz6JPl9l6JpD5wq3BwcG3XNC1fPnyrFu37rYxZbZvQEAAM2bMYMaMGbfd96+aN2+eLYvLikjWqWRNzlFCXkRERCQfa926dYZtbm5u3Lhxw27b2bNnOXbsGEWLFgXSZtt17NiRdevW0b59ewBefPFFgoKC2L17N25ubkBa0r1p06a8+uqrGRLyvr6+bNy40ZZQT0pKYvTo0TRs2JBNmzbh7Jz2UbRWrVr07dvXbhZ97969WbhwIevXr7dLRixYsIBmzZoRFBR0y6TC3zVx4kScnJzo1q2b3fZatWrRtGlTQkJCiIiIYO7cubz00ktcvHjRNrMvMDAQHx8ffv75Z7t9IyIi+O2334C0UjXFixfHxcWFZcuW0bNnTx577DHb2Pr167Njxw7bzMe/KykpiX/961+UK1eOhg0b3nF8Vs4zM4sXLyYlJUXlakREREREbkMJeREREZF8bObMmRkW47x5xnm6xx9/3JaMh7Q65pC2SCiklWLZtGkTY8eOJTY21lZuBSA0NJQxY8Zw4cIFSpUqZds+YMAAu+fas2cPERERjB8/3paMh7R64+m10tO1bt2akiVLsnDhQltC/tChQ/z666/Mnj0buP3MvXu1aNEivvjiC0aNGkWlSpXs+v5amqdfv360a9eOqVOnMnToUEqXLo3FYmHgwIFMnDiR119/nWeeeYaYmBhGjRpFUlISAAkJCbZjFC1alDp16tC9e3caN27M8ePHGT9+PN27d2f9+vW4u7v/7XMaMmQIv/32G6tXr7Z73W8lK+eZmUWLFuHv759pbXkRERERyVssRlrL1mNm7+HyLL0OIiIiIvnYAw88QOvWre1aixYtMowLCgqye5yenL927RoAx48fxzRNRo8ejb+/v10bM2YMAFeuXLE7Rrly5ewenzlzBiDDoqLOzs4EBwfbbbNYLDz11FN8++23xMfHA7Bw4ULc3d1vuaDprSQkJBAWFmbXMvPTTz/Rv39/QkNDee+99+54XMMwGD58OCkpKWzZssW2fezYsfTv359JkyZRuXJlGjRogLOzM/379wfSSvJAWjmhhx9+mCZNmjB+/Hg6duzIiBEjWLZsGdu3b2fOnDl3dZ6Z+eCDD5g9ezbjxo3jH//4xz0d41bnebOTJ0+yc+dOHn/88Swl/UVERERECiol5EVEREQk01nz8Gf9V6vVCsDIkSNZv359pu2vifbM6qjfjd69exMXF8e3336LaZosWrSI9u3b4+3tfVfHWbx4MSVKlLBrf3XgwAEee+wxatSowdKlS7OcVC5TpgyQdgdBOldXVz7//HMuXrzItm3bOHr0KOvWrSM6OhqLxWJ7nZYtW8bly5ftytUAPPLII3h5eWUoe3O35s6dy6uvvsrzzz/Pm2+++beOldl53mzRokUAKlcjIpLPzZ07l7i4OEeHISK5wJJDTVSyRkRERESyoHz58gC4uLhkWpc+K8qWLQukzba/eZZ+SkoKp0+fplatWnbja9SoQd26dVm4cCGlS5fm7NmzfPTRR3f9vKGhoaxfv/6W/SdOnKBt27YEBASwZs0a2wz2rEgv6ePv75+hLzAwkMDAQABSU1PZsmULjRo1sh3/8uXLtr6bmaZJamoqKSkpWY7jr7777jueffZZunTpwsyZM+/5OOlud56QlpCvUKECjRs3/tvPJSIiIiKSn+mLCRERERG5o4CAAJo3b86nn37KpUuXMvRfvXr1jsdo0KABfn5+zJ492y7ZvHDhQltpnL96+umn+fHHH/nXv/6Fn58f7dq1s/UlJydz5MiRTOO5WYkSJTKU7UkXFhZGmzZtsFgsrFu37pYJ58jIyAyJ8+TkZCZMmICrq2umZYBuNnnyZC5dusSIESNs29Jr+3/99dd2Y1euXMn169epW7fubY95K9u2beOJJ56gWbNmLFy4EIsl84/8mb1+93Ke+/bt4/fff6dnz573FK+IiIiI3H8Mw8iRJpohLyIiIpKvrV27liNHjmTY/uCDD9pmvWfVzJkzadq0KTVr1mTAgAGUL1+ey5cvs3PnTs6fP8+BAwduu7+rqytvv/02Q4cOpWXLlvTo0YPTp08zd+5cKlSokOkH9J49ezJq1ChWrFjBCy+8gIuLi63vwoULVK1alT59+jB37ty7Opd0bdu25eTJk4waNYrt27ezfft2W19gYKBtgdKVK1fy7rvv0q1bN8qVK0dkZCSLFi3i0KFDvP/++xQvXty234IFC1i2bBnNmjWjSJEibNiwgW+++YZnn32Wrl272sZ16NCB6tWrM3bsWM6cOWNb1HXGjBmUKFHCVnM+3bvvvgvA4cOHAfj3v/9tize9JM2ZM2d47LHHMAyDbt26sWTJErtj1KpVy3YnQmav392cZ7qFCxcCKlcjIiIiIpIVSsiLiIiI5GNvvfVWptvnzJlz1wn5atWqsWfPHt555x3mzp1LREQEAQEB1K1b95bP81dDhgzBNE2mTJnCyJEjqV27NitXrmTYsGG4u7tnGB8YGEibNm1Ys2YNTz/99F3FmxXpXyJMmjQpQ98jjzxiS8jXrFmTatWqsWDBAq5evYqrqyt16tThm2++ybDIbOXKlYmMjGTcuHEkJCQQEhLCJ598wnPPPWc3ztXVlZ9++olx48axevVqvvrqKzw9PenUqRPvv/8+xYoVsxs/evRou8dffvml7c/pCflTp04RHR0NwODBgzOc05gxYzKUBrrZ3ZwnpK0t8PXXX1OvXj1CQkJueVwRkfvF3Llz6dev3y37d+7cqfJbwPLly1m8eDG7d+8mLCyMMmXK0L59e0aPHo2Pj4/d2ODgYNvC7TcbOHAgn3zyid229evX884777B3717c3Nxo1aoVkydPzrC4+40bN5g2bRr//ve/OX36NEWLFuXBBx/k7bffpnr16rZxly5dYvr06fznP/9hz549xMXFsXnzZpo3b57peSUlJTF58mTmz5/P6dOn8fb2pkGDBnz66aeULl36tq/J5cuXee2111i9ejWxsbFUrVqV119/PdP3xw0bNvDee+9x8OBBUlJSqFy5MkOHDs2RzzIiOSUnar6rVEsaw0xfqUtERERExAGsViv+/v506dKF2bNnZ+jv3LkzBw8e5Pjx4w6ITkRE8pP0hPzYsWMpV65chv62bdtm+EK0ICpWrBglS5akU6dOBAUFcfDgQT755BPKly/P3r177RZuDw4OpmjRonZl2SDtC+oHHnjA9njVqlV07NiRevXq8fTTTxMTE8P06dNxc3Nj3759dmXjunbtysqVKxkwYAD16tXj4sWLzJw5k4SEBA4ePGhbl2bLli20aNGCSpUqUaxYMXbu3HnLhHxycjL/+Mc/2LFjBwMGDKBWrVpcu3aN//znP4wZM8Yu0f9XMTEx1K9fn8uXL/Piiy9SvHhxvvnmG7Zt28bChQvtyratXLmSTp060aRJE5588kkMw7CNnTp1KsOHD7/rn4dIboqJicHb25tXXbxxy+YSM4mmycTkaKKjo/Hy8srWY+clmiEvIiIiIrnmxo0buLm52ZWnmT9/PpGRkZlePF+6dInVq1fzf//3f7kYpYiI5Hft2rWjQYMGjg6D69evU7hwYUeHkcHSpUszvC/Xr1+fPn36sHDhQp599lm7vlKlStGrV6/bHvPVV1+lfPny/Pzzz7i6ugJp5dvq1avHhAkTmDJlCpBWUm358uWMHDmSDz74wLb/ww8/TMuWLVm+fLktqV2/fn0iIiLw9fVl6dKlmc5WTzdt2jS2bt3K9u3b7b4oyIpPP/2U48ePs3HjRlq2bAnACy+8QOPGjRkxYgTdunWznVN66blNmzbh5uYGpN0tUKVKFebOnauEvIjoTgERyTrDMHj77bcdHYaIiORhu3btol69erz//vt8+umnDBw4kGeffZYaNWrYXUSfOnWKBQsW8OSTT+Li4sLAgQMdGLWIiBQ0p0+fxjAMJk+ezGeffUaFChVwc3OjYcOG7N69O8P4I0eO0K1bN3x9fXF3d6dBgwasXLnSbszcuXMxDIOtW7cyaNAgAgIC7MqkzJw5k/Lly1OoUCEeeOABfvrpJ5o3b25LjMfFxVG4cGFefPHFDM9//vx5nJycGD9+fJYXPb+dzL4k79y5MwC///57pvskJSVx/fr1TPsiIyP57bff6Ny5sy1xDVC7dm2qVq1qt8B5bGwskFa27mYlSpQAsJud7+npia+v7x3Px2q1Mn36dDp37swDDzxASkoK8fHxd9wv3U8//YS/v78tGQ9gsVjo0aMHYWFhbN261bY9JiaGokWL2pLxAM7OzhQrVswudpH7ncGfZWuyq2lJ1zRKyIvksoMHD9KtWzfKli2Lu7s7pUqV4tFHH+Wjjz5ydGgOsWPHDpo2bYqHhwfFixdn2LBhxMXFOTosERHJIcHBwZQpU4YPP/yQoUOH8t1339G7d282btxod4G+detWnn76aU6dOsW8efMyXUxURETkXkVHRxMeHm7XIiIiMoxbtGgRH3zwAQMHDuTdd9/l9OnTdOnSheTkZNuYw4cP07hxY37//Xdee+01pkyZQuHChenUqRMrVqzIcMxBgwbx22+/8dZbb/Haa68BMGvWLIYMGULp0qWZNGkSDz/8MJ06deL8+fO2/YoUKULnzp1ZvHgxqampdsf86quvME2Tp556yrZo9+uvv55dLxcAYWFhAJmW9Nm0aRMeHh4UKVKE4OBgpk+fbtefmJgIkGlC2sPDg4sXL9qOX6FCBUqXLs2UKVP4/vvvOX/+PP/97395/vnnKVeuHE888cRdx/7bb79x8eJFatWqxXPPPUfhwoUpXLgwtWrVYvPmzXfcPzEx8ZaxA/zyyy+2bc2bN+fw4cOMHj2a48ePc+LECcaNG8eePXsYNWrUXccuIvmPStaI5KIdO3bQokULgoKCGDBgAMWLF+fcuXPs2rWL6dOnM3ToUEeHmKv2799Pq1atqFq1KlOnTuX8+fNMnjyZY8eOsXbtWkeHJyIiOSA4ODjDjMHM9O3bl759++Z8QCIiUiC1bt06wzY3Nzdu3Lhht+3s2bMcO3aMokWLAhASEkLHjh1Zt24d7du3B+DFF18kKCiI3bt322ZFDxo0iKZNm/Lqq6/aZpan8/X1ZePGjTg5OQFpM8tHjx5Nw4YN2bRpE87OaamaWrVq0bdvX7tZ9L1792bhwoWsX7+etm3b2rYvWLCAZs2aERQUxOnTp//mq5O5iRMn4uTkRLdu3ey216pVi6ZNmxISEkJERARz587lpZde4uLFi0ycOBFIm+3u4+PDzz//bLdvREQEv/32G5BWqqZ48eK4uLiwbNkyevbsyWOPPWYbW79+fXbs2JFhUdmsOHbsGJBWtsbX15dPP/0UgPfff5+2bduye/fu2y56HhISwoYNGzhz5oytfj2kzZxPjz3d6NGjOXXqFO+99x7vvvsukJa4X7ZsGR07drzr2EUcxWIYWLK5hrxmhqdRQl4kF7333nt4e3uze/fuDB8irly54pigHOiNN96gaNGibNmyxbaYR3BwMAMGDODHH3+kTZs2Do5QRERERETyo5kzZ1K5cmW7bekJ8ps9/vjjtmQ8pNUxBzh58iSQVopl06ZNjB07ltjYWFu5FYDQ0FDGjBnDhQsXKFWqlG37gAED7J5rz549REREMH78eFsyHuCpp57KUG+8devWlCxZkoULF9oS8ocOHeLXX3+1LYweHByMaZp394LcwaJFi/jiiy8YNWoUlSpVsuv76xft/fr1o127dkydOpWhQ4dSunRpLBYLAwcOZOLEibz++us888wzxMTEMGrUKJKSkgBISEiwHaNo0aLUqVOH7t2707hxY44fP8748ePp3r0769evx93d/a7iT78LOzY2ln379lGmTBkAWrZsScWKFZk0aRILFiy45f7PPvssn3zyCT169GDatGkEBgbyzTff2O6AuDl2Nzc3KleuTLdu3ejSpQupqal89tln9OrVi/Xr19O4ceO7il1E8h99MSGSi06cOEH16tUz/UY/ICDA7vGcOXNo2bIlAQEBuLm5Ua1aNWbNmpVhv+DgYNq3b8+WLVto0KABhQoVombNmmzZsgWA5cuXU7NmTdzd3alfvz779u2z279v374UKVKEkydPEhoaSuHChSlZsiRjx47N0oe4Cxcu8MwzzxAYGIibmxvVq1fnyy+/vON+MTExrF+/nl69etmtrN27d2+KFCnCN998c8djiIiIiIiI3IsHHniA1q1b27UWLVpkGBcUFGT3OD05f+3aNQCOHz+OaZqMHj0af39/uzZmzBgg4+SrcuXK2T0+c+YMABUrVrTb7uzsTHBwsN02i8XCU089xbfffmurgb5w4ULc3d1vu6BpZhISEggLC7Nrmfnpp5/o378/oaGhvPfee3c8rmEYDB8+nJSUFNt1KcDYsWPp378/kyZNonLlyjRo0ABnZ2f69+8PpJXkgbRyQg8//DBNmjRh/PjxdOzYkREjRrBs2TK2b9/OnDlz7uo84c9SOQ899JAtGQ9pP9+mTZuyY8eO2+5fq1YtFi1axIkTJ3jooYeoWLEiH374If/617/sYgcYMmQI33//PV9//TVPPPEETz31FBs2bKBEiRKZ1v8XuV9ld/349CaaIS+Sq8qWLcvOnTs5dOgQNWrUuO3YWbNmUb16dR577DGcnZ35/vvvGTRoEFarlcGDB9uNPX78OD179mTgwIH06tWLyZMn06FDBz755BPeeOMNBg0aBMD48ePp0aMHR48exWL589dgamoqbdu2pXHjxkyaNIkffviBMWPGkJKSwtixY28Z4+XLl2ncuDGGYTBkyBD8/f1Zu3Yt/fv3JyYmhpdeeumW+x48eJCUlBQaNGhgt93V1ZU6depk+OJARHKO1Wrl4sWLeHp6YmTzLYkiIpJ/mKZJbGwsJUuWtPssKZKfZTZrHrBNXrJarQCMHDmS0NDQTMf+NdH+dxf27N27Nx988AHffvstTz75JIsWLaJ9+/Z4e3vf1XEWL15Mv3797Lb9dVLWgQMHeOyxx6hRowZLly61m8F/O+lJ78jISNs2V1dXPv/8c9577z3++OMPAgMDqVy5Mj179sRisdhep2XLlnH58mW7cjUAjzzyCF5eXvz888+88MILd3WuJUuWBDIuFAtpk+Oycv3ZrVs3HnvsMQ4cOEBqair16tWzfeGQfrdFUlKS7U6Cm39Puri40K5dO2bMmEFSUpLdujki9yuLkday9ZjZe7g8Swl5kVw0cuRI2rVrR506dXjggQd4+OGHadWqFS1atMDFxcVu7NatW+0+qA0ZMoS2bdsyderUDAn5o0ePsmPHDpo0aQJAtWrVCA0NZcCAARw5csQ2q6No0aIMHDiQbdu20bx5c9v+N27coG3btnz44YdAWr3DDh06MHHiRIYNG5bpoj0A//d//0dqaioHDx7Ez88PgOeff54nn3ySt99+m4EDB97yw+alS5cAKFGiRIa+EiVK2GrxiUjOu3jxot1MIRERkds5d+6cXU1rkYKsfPnyQFrCNbO69FmRXpP8+PHjdrP0U1JSOH36dIba5jVq1KBu3bosXLiQ0qVLc/bsWT766KO7ft7Q0FDWr19/y/4TJ07Qtm1bAgICWLNmjd0s8DtJL+nj7++foS8wMNCWGE9NTWXLli00atTIdvzLly/b+m5mmiapqamkpKRkOY50NWvWxMXFxa7We7qLFy9mGmdmXF1dadiwoe3xhg0bgD/XJIiIiCAlJSVD7ADJyclYrdZM+0SkYFFCXiQXPfroo+zcuZPx48ezbt06du7cyaRJk/D39+fzzz+3mwFwcyI7Ojqa5ORkHnnkEdatW0d0dLTd7Idq1arZkvEAjRo1AtLq4d18i2X69pMnT9ol5CEt4Z8ufcb76tWr2bBhQ6ar2JumybJly+jRowemaRIeHm7rCw0N5euvv2bv3r089NBDmb4W6TX20hc9upm7u7tdDT4RyVmenp5AWoLl5hJSIiIiN4uJiaFMmTK29w0RSZtd3bx5cz799FOGDh2aYcLR1atX75jsbdCgAX5+fsyePZt+/frZZqEvXLjQVhrnr55++mlGjRqFm5sbfn5+tGvXztaXnJzMiRMn8Pb2znQCVLoSJUrcsj8sLIw2bdpgsVhYt27dLc8hMjISb29vuzsJkpOTmTBhAq6urpmWAbrZ5MmTuXTpkt0XCumzzb/++mvefvtt2/aVK1dy/fp16tate9tjZsbT05N//OMfrFq1iiNHjlClShUAfv/9d3bs2MHAgQNtY+Pj4zl79izFihW75eQ0SFso9pNPPqF9+/a2mAMCAvDx8WHFihWMHTvWNhM+Li6O77//nipVqvztOyREcktOlJjRDPk0SsiL5LKGDRuyfPlykpKSOHDgACtWrGDatGl069aN/fv3U61aNQB+/vlnxowZw86dO221AdP9NSH/17qG6X1/nfGavv2vH+osFottZke69A8Up0+fzvQ8rl69SlRUFJ999hmfffZZpmNut1Bt+oeQxMTEDH03btzQhxSRXJRepsbLy0sJeRERuSOVN5P8YO3atRw5ciTD9gcffDDDtdGdzJw5k6ZNm1KzZk0GDBhA+fLluXz5Mjt37uT8+fMcOHDgtvu7urry9ttvM3ToUFq2bEmPHj04ffo0c+fOpUKFCpn+m+vZsyejRo1ixYoVvPDCC3Z3XF+4cIGqVavSp08f5s6de1fnkq5t27acPHmSUaNGsX37drZv327rCwwM5NFHHwXSkuTvvvsu3bp1o1y5ckRGRrJo0SIOHTrE+++/T/HixW37LViwgGXLltGsWTOKFCnChg0b+Oabb3j22Wfp2rWrbVyHDh2oXr06Y8eO5cyZM7ZFXWfMmEGJEiVsNefTvfvuuwAcPnwYgH//+9+2eN98803buPfff5+NGzfSsmVLhg0bBsCHH36Ir68vb7zxhm3cf//7X1q0aMGYMWPsvhCoVq0a3bt3JygoiFOnTjFr1ix8fX355JNPbGOcnJwYOXIkb775Jo0bN6Z3796kpqbyxRdfcP78+dsuHCsiBYcS8iIOkn6rW8OGDalcuTL9+vVjyZIljBkzhhMnTtCqVSuqVKnC1KlTKVOmDK6urqxZs4Zp06bZ6hSmu1VdwzvVO/w70mPo1asXffr0yXTMX2+tvFn6TIz00jU3u3Tpkq3Gn4iIiIiISHZ76623Mt0+Z86cu07IV6tWjT179vDOO+8wd+5cIiIiCAgIoG7durd8nr8aMmQIpmkyZcoURo4cSe3atVm5ciXDhg3D3d09w/jAwEDatGnDmjVrePrpp+8q3qxI/xJh0qRJGfoeeeQRW0K+Zs2aVKtWjQULFnD16lXbmmDffPNNhkVmK1euTGRkJOPGjSMhIYGQkBA++eQTnnvuObtxrq6u/PTTT4wbN47Vq1fz1Vdf4enpSadOnXj//fczzFofPXq03eMvv/zS9uebE/LVqlVj69atvPrqq7z77rtYLBZatmzJBx98QKlSpe74mtSuXZs5c+Zw+fJlihUrRo8ePXjnnXcICAiwG/d///d/lCtXjunTp/POO++QmJhIrVq1WLp0qd0XDyL3OwsGFrL3S3jNkE+jhLzIfSB9YdP05PT3339PYmIiK1eutJv9vnnz5hx5fqvVysmTJ22z4gH++OMPAIKDgzPdx9/fH09PT1JTU++pVmKNGjVwdnZmz5499OjRw7Y9KSmJ/fv3220TERERERHJDn379qVv3753HBccHHzLiUyZbS9fvjzz5s37W889dOhQhg4dantstVo5derULUu0uLq6UqFCBbvypXeKPauyun/9+vVZuXJllsY+8MADbN26NUtjixYtytSpU5k6deodx97NudarV++2dfMBmjdvnukxv/rqqyw/T8+ePenZs2eWx4tIwaIvJkRy0ebNmzN9Y1+zZg0AISEhwJ8z228eGx0dzZw5c3IsthkzZtj+bJomM2bMwMXFhVatWmU63snJia5du7Js2TIOHTqUof/q1au3fT5vb29at27NggULiI2NtW3/97//TVxcXIbZFCIiIiIiIvnVjRs3Mlwrzp8/n8jIyAzrf0HaZK7Vq1fnyOx4EREAi5EzTTRDXiRXDR06lPj4eDp37kyVKlVISkpix44dLF68mODgYPr16wdAmzZtcHV1pUOHDgwcOJC4uDhmz55NQEBApiVe/i53d3d++OEH+vTpQ6NGjVi7di2rV6/mjTfeuO0CRBMmTGDz5s00atSIAQMGUK1aNSIjI9m7dy8bNmwgMjLyts/73nvv8eCDD/LII4/w3HPPcf78eaZMmUKbNm1o27Ztdp+miIiIiIjIfWnXrl0MHz6c7t274+fnx969e/niiy+oUaOG3WSlU6dO8fPPP/P555/j4uJitxipiIjkDUrIi+SiyZMns2TJEtasWcNnn31GUlISQUFBDBo0iDfffBMfHx8gbab80qVLefPNNxk5ciTFixfnhRdewN/fn2eeeSbb43JycuKHH37ghRde4JVXXsHT05MxY8bcsd5hYGAg//3vfxk7dizLly/n448/xs/Pj+rVqzNx4sQ7Pm+9evXYsGEDr776KsOHD8fT05P+/fszfvz47Do1ERERERGR+15wcDBlypThww8/JDIyEl9fX3r37s2ECRNwdXW1jdu6dSv9+vUjKCiIefPm2S2aKiKSnSxkf2kVlWpJY5jZsbqjiORZffv2ZenSpcTFxTk6FBFxkJiYGLy9vYmOjsbLy8vR4YiIyH1K7xciIiL5X/r7/YRCRXE3srfGzA3T5LWEawX+s4RmyIuIiIiIZLOIiAi7dVji4+M5efIkV65cwdfX14GRiYiIiIiII+lOARERERGRv8k0TcLDwzl9+jTh4eH4+vqyf/9+W3vuuedo166dkvEiuWTWrFnUqlULLy8vvLy8aNKkCWvXrnV0WCIiInmGAVgwsrVpTdc0miEvIiIiInKPoqKimDdvHjM/nsWxP47atleqHMLgQS/Qp08ffHx8+OKLL7RGikguKl26NBMmTKBSpUqYpsm8efPo2LEj+/bto3r16lk6htVq5eLFi3h6emJk8y37IiKSf5imSWxsLCVLlsRi0dxnuTPVkBcRESngVBNY5N6sW7eO7j16EB8fT/WW7anRqj2FvHxIiIni0MZVHN60Cg8PD955+20mTpzI+fPncXbWfBjJu/L6+4Wvry8ffPAB/fv3z9L48+fPU6ZMmRyOSkRE8otz585RunRpR4fxt6W/33/gUZRCRvZ+wZBgWnklXjXkdUUgIiIiInKX1q1bR/v27anYpAVdRk/Ds1igXX/NRzsSG36Z5eOGM2LECLp27apkvIiDpKamsmTJEq5fv06TJk1uOS4xMZHExETb4/S5a+fOnSvQSQMREbm9mJgYypQpg6enp6NDkTxCVwUiIiIiInchKiqK7j16ULFJC3pNmY/TLRLtnsUC6T5uFu+1CmHN2rVERUXh4+OTu8GKFGAHDx6kSZMm3LhxgyJFirBixQqqVat2y/Hjx4/nnXfeybA9vQ69iIjI7eS38mYWsn/xURX0SaPXQURERETkLsybN4/4+Hi6jJ52y2R8usObvqdklVokJiYyf/78XIpQRABCQkLYv38///nPf3jhhbQ1HX777bdbjn/99deJjo62tXPnzuVitCIiIvcXi5EzTZSQl3xg7ty5GIZxy7Zr1y5Hh3hfWL58OY8//jjly5fHw8ODkJAQRowYQVRUVIaxwcHBmb6Wzz//fIax69evp2nTpnh4eFC0aFG6devG6dOnM4y7ceMG48ePp1q1anh4eFCqVCm6d+/O4cOH7cZdunSJ1157jRYtWtgW0NqyZUum5/Tjjz/Sv39/atSogZOTE8HBwffwyqQ5ceIE7u7uGIbBnj177vk8RUQkfzNNk5kfz6J6y/YZytRkZs+3i2jUrS/VW/yTGTM/Rss3ieQeV1dXKlasSP369Rk/fjy1a9dm+vTptxzv5uZmmw2vWfEiIiKSU1SyRvKNsWPHUq5cuQzbK1as6IBo7j/PPfccJUuWpFevXgQFBXHw4EFmzJjBmjVr2Lt3L4UKFbIbX6dOHUaMGGG3rXLlynaPV61aRceOHalXrx4TJkwgJiaG6dOn07RpU/bt24e/v79t7FNPPcXKlSsZMGAA9erV4+LFi8ycOZMmTZpw8OBBypYtC8DRo0eZOHEilSpVombNmuzcufOW57Ro0SIWL15MvXr1KFmy5N96fYYPH46zs7Nd3dB7OU8REcnfIiIiOPbHUXr2fyVDX+2US1y1FOai5c8k3gtz1wDgWsiDr177jsjISPz8/HItXhH5k9VqzfSznoiIiGRkwcBC9k5pz+7j5VVKyEu+0a5dOxo0aODoMLh+/TqFCxd2dBgZLF26lObNm9ttq1+/Pn369GHhwoU8++yzdn2lSpWiV69etz3mq6++Svny5fn5559xdXUFoEOHDrbE9ZQpUwC4cOECy5cvZ+TIkXzwwQe2/R9++GFatmzJ8uXLGT58uC2miIgIfH19Wbp0Kd27d7/l87///vvMnj0bFxcX2rdvz6FDh7L8etxs3bp1rFu3jlGjRvHuu+/e83mKiEj+FxcXB0AhLx/7DtOkXmoYZirMd62N1bC/ETV9fGxsrBLyIrng9ddfp127dgQFBREbG8uiRYvYsmUL69atc3RoIiIiUsCpZI0UGKdPn8YwDCZPnsxnn31GhQoVcHNzo2HDhuzevTvD+CNHjtCtWzd8fX1xd3enQYMGrFy50m5MermcrVu3MmjQIAICAihdurStf+bMmZQvX55ChQrxwAMP8NNPP9G8eXNbYjwuLo7ChQvz4osvZnj+8+fP4+TkxPjx40lOTubIkSNcunTpns//r8l4gM6dOwPw+++/Z7pPUlIS169fz7QvMjKS3377jc6dO9uS1AC1a9ematWqfP3117ZtsbGxAAQG2t/aX6JECQC72fmenp74+vpm4YygZMmSuLi4ZGnsrSQnJ/Piiy/y4osvUqFChQz9d3OeIiKS/xUpUgSAhJgo+w7D4A+LH85YqZ16OcN+6eM9PT1zOEIRAbhy5Qq9e/cmJCSEVq1asXv3btatW8ejjz7q6NBERETyBNWQzzlKyEu+ER0dTXh4uF2LiIjIMG7RokV88MEHDBw4kHfffZfTp0/TpUsXkpOTbWMOHz5M48aN+f3333nttdeYMmUKhQsXplOnTqxYsSLDMQcNGsRvv/3GW2+9xWuvvQbArFmzGDJkCKVLl2bSpEk8/PDDdOrUifPnz9v2K1KkCJ07d2bx4sWkpqbaHfOrr77CNE2eeuopLly4QNWqVXn99dez6+UCICwsDIBixYpl6Nu0aRMeHh4UKVKE4ODgDPU202/3/WupGwAPDw8uXrxoO36FChUoXbo0U6ZM4fvvv+f8+fP897//5fnnn6dcuXI88cQT2Xped+Nf//oX165d480338y0/27OU0RE8j8/Pz8qVQ7h0MZVGfr+41yKVCzUTg3DYlrt+g5vXEWlyiFZ/tJZRP6eL774gtOnT5OYmMiVK1fYsGGDkvEiIiJyX1DJGsk3WrdunWGbm5sbN27csNt29uxZjh07RtGiRQEICQmhY8eOrFu3jvbt2wPw4osvEhQUxO7du3FzcwPSku5Nmzbl1Vdftc0sT+fr68vGjRtxcnIC0maWjx49moYNG7Jp0yacndP+qdWqVYu+ffvazaLv3bs3CxcuZP369bRt29a2fcGCBTRr1oygoKAcWzx04sSJODk50a1bN7vttWrVomnTpoSEhBAREcHcuXN56aWXuHjxIhMnTgTSZrv7+Pjw888/2+0bERHBb7/9BqSVqilevDguLi4sW7aMnj178thjj9nG1q9fnx07duDj45Mj53cnYWFhjBs3jsmTJ99y0a67OU8REcn/DMNg8KAXGDFyJLHhl+0Wdk0xnDjiVIzqqVeomxrGL85p65vEXA3j8ObVTJ0yBcPQtCARERERuf8Z/2vZfUzRDHnJR2bOnMn69evt2tq1azOMe/zxx23JeEirYw5w8uRJIK1EyaZNm+jRowexsbF2s+1DQ0M5duwYFy5csDvmgAEDbMl4gD179hAREcGAAQNsyXhIW9j05ueGtC8SSpYsycKFC23bDh06xK+//mqr4R4cHIxpmsydO/ceX52MFi1axBdffMGIESOoVKmSXd/KlSsZNWoUHTt25JlnnmHr1q2EhoYydepU2wx/i8XCwIED2bhxI6+//jrHjh3jl19+oUePHiQlJQGQkJBgO2bRokWpU6cOr732Gt9++y2TJ0/m9OnTdO/ePcOXJrklvTb8X+vn3+xuz1NERPK/Pn364OHhwfJxw0lNSbHr2+1UklQs1Ey9jJNpJTUlhW/ffRkPDw969+7toIhFREREROR+oYS85BsPPPAArVu3tmstWrTIMC4oKMjucXqC/Nq1awAcP34c0zQZPXo0/v7+dm3MmDFAWk3Km5UrV87u8ZkzZwCoWLGi3XZnZ2eCg4PttlksFp566im+/fZb4uPjAVi4cCHu7u63XdA0MwkJCYSFhdm1zPz000/079+f0NBQ3nvvvTse1zAMhg8fTkpKClu2bLFtHzt2LP3792fSpElUrlyZBg0a4OzsTP/+/YE/6+xGR0fz8MMP06RJE8aPH0/Hjh0ZMWIEy5YtY/v27cyZM+euzjM77Nq1i3//+99MmzYNi+X2vwqzep4iIlIw+Pj4sOSbbzi+czMLRvQm5uqf77cphhO/OfnjjJVq0X+wYERvju3czNIlSxx2R5iIiIiIyN1SDfmco4S8FDg3z2S/mWmaAFitaTVfR44cmWHGfXr7a6I9s/rid6N3797ExcXx7bffYpomixYton379nh7e9/VcRYvXkyJEiXs2l8dOHCAxx57jBo1arB06VK7Gfy3U6ZMGSDtDoJ0rq6ufP7551y8eJFt27Zx9OhR1q1bR3R0NBaLxfY6LVu2jMuXL9uVqwF45JFH8PLyylAOJjeMGjWKhx9+mHLlynH69GlOnz5NeHg4AJcuXeLs2bO2sVk9TxERKThCQ0NZtWoVFw78h0n/rMtXrz7Lrz9+y7FdW5i7eQ8RYRcpc2Ev4b/tZfXq1bRp08bRIYuIiIiIZJkFI0eaqIa8SAbly5cHwMXFJdO69FlRtmxZIG22/c2z9FNSUjh9+jS1atWyG1+jRg3q1q3LwoULKV26NGfPnuWjjz666+cNDQ1l/fr1t+w/ceIEbdu2JSAggDVr1tzVzO70kj7+/v4Z+gIDAwkMTKuhm5qaypYtW2jUqJHt+JcvX7b13cw0TVJTU0n5y+3+ueHs2bOcOXMmw90NAI899hje3t5ERUXZbb/TeYqISMESGhrK2TNnmD9/PjNmfsxXr31n66s6bAADOrbh7H82UahCrdscRUREREREChIl5EX+IiAggObNm/Ppp58ydOjQDLPMr169mmlS+mYNGjTAz8+P2bNn069fP9ss9IULF9pK4/zV008/zahRo3Bzc8PPz4927drZ+pKTkzlx4gTe3t6ZznpPd6tZ8ZC2gGmbNm2wWCysW7fulucQGRmJt7e33Z0EycnJTJgwAVdX10zLAN1s8uTJXLp0ye4LhcqVKwPw9ddf8/bbb9u2r1y5kuvXr1O3bt3bHvPvyuz1++yzz2wlgtJt2rSJjz76iMmTJ1OlSpXbHjOz8xQRkYLHx8eHYcOGMXToUCIjI4mNjcXT05OiPt5wcBvEhmOmpmLc4g49EREREZH7UU6UmFGpljRKyEu+sXbtWo4cOZJh+4MPPmib9Z5VM2fOpGnTptSsWZMBAwZQvnx5Ll++zM6dOzl//jwHDhy47f6urq68/fbbDB06lJYtW9KjRw9Onz7N3LlzqVChAoaR8Tdaz549GTVqFCtWrOCFF17AxcXF1nfhwgWqVq1Knz597nlh17Zt23Ly5ElGjRrF9u3b2b59u60vMDCQRx99FEhLkr/77rt069aNcuXKERkZyaJFizh06BDvv/8+xYsXt+23YMECli1bRrNmzShSpAgbNmzgm2++4dlnn6Vr1662cR06dKB69eqMHTuWM2fO0LhxY44fP86MGTMoUaKErRZ7unfffReAw4cPA/Dvf//bFu+bb75pG/frr7+ycuVKIO1uhOjoaNu+tWvXpkOHDrd8/TIrHZA+I/6RRx6hQYMGd32eIiJScBmGgZ+fH35+frZtZmBZzLBTcOk4lA5xYHQiIiIiInK/UEJe8o233nor0+1z5sy564R8tWrV2LNnD++88w5z584lIiKCgIAA6tate8vn+ashQ4ZgmiZTpkxh5MiR1K5dm5UrVzJs2DDc3d0zjA8MDKRNmzasWbOGp59++q7izYr0LxEmTZqUoe+RRx6xJeRr1qxJtWrVWLBgAVevXsXV1ZU6derwzTffZFhktnLlykRGRjJu3DgSEhIICQnhk08+4bnnnrMb5+rqyk8//cS4ceNYvXo1X331FZ6ennTq1In333+fYsWK2Y0fPXq03eMvv/zS9uebE/J79+7NMDb9cZ8+fWwJ+b8rq+cpIiJiJ7AcXDmDGX4BSlTAcNJHbxERkbthpqbo/VPEQQyyf0a7KsinMcz0lSxFJMdZrVb8/f3p0qULs2fPztDfuXNnDh48yPHjxx0QnYgUVDExMXh7exMdHY2Xl5ejwxHJV8xLJzHDTkKx0ljK3L4cmsj9rqC9XxS08xW535gJsXAtDIoUBU+/TO80F7kf5Lf3i/Tzme3lh4eRvSn5eNPKgJiIfPNa3SuV7hHJITdu3OCv33fNnz+fyMhImjdvnmH8pUuXWL16dY7MjhcREREHCQwGixNEXMRMzf1FzEVERPIsixOYVogJh8iLmNZUR0ckUqAYOdREJWtEcsyuXbsYPnw43bt3x8/Pj7179/LFF19Qo0YNu9Ivp06d4ueff+bzzz/HxcWFgQMHOjBqERERyU6GxQKBwZiXTmBe+AMjqJqjQxIREckbXN3BYoHUFEiIhZQkTN+SGC5ujo5MpECwGAaWbL4zxaKUPKCEvEiOCQ4OpkyZMnz44YdERkbi6+tL7969mTBhAq6urrZxW7dupV+/fgQFBTFv3jy7RVNFREQkHwgoC5dPQ2QYZqnKqoUrIiKSBYZhwXTzgPgYwITkREiMByXkRSSP09WASA4JDg5m5cqVdxzXt29f+vbtm/MBiYiIiEMYFgsUL4958Rjm+aMYZas7OiQREZG8wdUD4mPBMNJmy3sU3JrTIrktJ0rMaH58GtWQFxERERHJaQFl0mrhXruMmZrs6GhERETyhkKe4FUs7f9NEyIvOjoiEZG/TQl5EREREZEcZhgWjBIVwLRinjvq6HBERETyBMPJGcOrGBQtAYYFkhIwE+MdHZZIgaBFXXNOgSpZY7VauXjxIp6enhjZvCiBiIjkH6ZpEhsbS8mSJbFY9N21iGQT/zJw6QREXcFMScZwdnF0RCIiInmCYRiY/kFw9QxEXsQsXh7D0Od0EcmbClRC/uLFi5QpU8bRYYiISB5x7tw5Spcu7egwRCSfMAwDSlbEPH8U89zvGOVqOTokERGRPMNwdsX08IbrUWmla/z0OV0kJ6mGfM4pUAl5T09PIC3B4uWlhUBERCRzMTExlClTxva+ISKSbYqVhovHITpcs+RFRETulpc/xMdAYgJmUgKGayFHRyQictcKVEI+vUyNl5eXEvIiInJHKm8mItnNMAwoVQnz3BHMM4cxKtRxdEgiIiJ5hmEYmMXKwNWzEHEBs3gFfWYXySGGYWT7vy9Dc+SBApaQFxERERFxOL9ScOEYxEZgpiRhOLs6OiIREZE8w3Bxw/TwgvhouHYJfEvecmxERAStWrWyPY6Pj+fkyZNcuXIFX1/f3AhXJM9SyZqco4S8iIiIiEguMgwDSlfGPPs75unDGBXrOjokERGRvMU7ABJi4cZ1zKQbGK7umKZJREQEcXFxFClSBD8/P/z8/Ni/f79tt8mTJ7N161Yl40XEobQktYiIiIhIbvMtCRYniIvETE5ydDQiIiJ5imEYUKwMAClXzvDhhx8SUqUq/v7+lCtXDn9/f0KqVGX69OlERUXZ9vviiy/o37+/g6IWyVssOdREM+RFRERERHJd2iz5EMyzv2GePoRRqZ6jQxIREclTDBc3Tl2OICkmgsQrZykUXJWe/V+hkJcPCTFRHNq4ihEjRzL6rbdY8s03eHp6cu3aNdq3b+/o0EWkgFNCXkRERETEEXxLwPmjcP0aZnIihouboyMSERHJM9atW0fHjh3Zu/47nu7TF6/uxbhm/TPNVfPRjsSGX2b5uOG0b9+eli1b0rt3b5ydlQoTyQrDSGvZeszsPVyepTsFREREREQcwDAMjDJVwDQxTx10dDgiIiJ5RlRUFN179KDcA83YXqQ6Tk5OdPSMAky7cZ7FAuk1ZT7lH3iYH3/8kW7dujkkXhGRmykhLyIiIiLiKEWLp9WSj4/GTE50dDQiIiJ5wrx584iPj6fL6GlE4s65FFecMXmoUFyGsU7OzlRs1ByAXbt25XKkInmXkUP/iRLyIiIiIiIOYxgGRlC1tFnyJ391dDgiIiL3PdM0mfnxLKq3bI9nsUAANlz3IgWDENcbeFtSMuxzaOMqSlerw4yZH2OaZoZ+EcnIyKEmSsiLiIjkaePHj6dhw4Z4enoSEBBAp06dOHr0qKPDEpG74ROQNks+IQYz6YajoxEREbmvRUREcOyPo9Ro9efirFYM1sZ5YwCdMild88LcNTzcezDH/jhKZGRkrsYrIvJXSsiLiIjkYVu3bmXw4MHs2rWL9evXk5ycTJs2bbh+/bqjQxORLDIMA6Ns9f/Nkj/g6HBERETua3FxaWVpCnn52G2/nOrCmRRXUs3M5+Cmj4+Njc3J8ETyDc2QzzlaWlpERCQP++GHH+wez507l4CAAH755ReaNWvmoKhE5K55+6fNkr8Rh3k9GkwrFPbBMHTZIiIicrMiRYoAkBATlaFvw3Vv0mbHZ3z/TB/v6emZc8GJiGSBZsiLSP6TnAgpyY6OQsQhoqOjAfD19b3lmMTERGJiYuyaiDiWYRgYpUPSZsn/sQfzjz0QF+XosERERO47fn5+VKocwqGNq24xIvMvsw9vXEWlyiG3/ZwsIn+yABYjm5ujT+o+oddBRPKf69FwPQqsqY6ORCRXWa1WXnrpJR566CFq1Khxy3Hjx4/H29vb1sqUKZOLUYpIZszUFMzzRyElCVJT0t7DkuIdHZaIiMh9xzAMBg96gcObVhEbfjlL+8RcDePw5tUMGTxId5+JiMMpIS8i+ZM1BeKjwTTvPFYknxg8eDCHDh3i66+/vu24119/nejoaFs7d+5cLkUoIrdkmuDiBoYBzi5p2xITHBuTiIjIfapPnz54eHiwfNxwUlNSbjs2NSWFb999GQ8PD3r37p1LEYrkfUYO/SdKyItIfmT873+Sk+BGnG1zREQEderUsbXKlSvj7OxMZGSkw0IVyS5Dhgxh1apVbN68mdKlS992rJubG15eXnZNJDukbv0e67ZVmJfOYFqtjg4nTzGcXTAq1gMP77RZ8lYr5g3NkBcREcmMj48PS775huM7N7NgRG9iroZlOi7mahgLRvTm2M7NLF2yBB8fn9wNVEQkE1rUVUTyJ9PENCA5Po6LlyMoUqQIfn5+7N+/3zZk8uTJbN26VTUEJU8zTZOhQ4eyYsUKtmzZQrly5RwdkhRQZkoK5pG9mGFn4ee14BuApWp9jEo1oXiQbg/PAsPVHSrWwzy+D+Ii7b5UFhEREXuhoaGsWrWK7j16MOmfdane4p9Ub9WeQl4+JMREcXjjKg5vXo2HhwerV6+mTZs2jg5ZJM/RJ/icoRnyIpLvJKaahF+L4sTJ07Tv9gTlypXD39+fkCpVmT59OlFRUQB88cUX9O/f37HBivxNgwcPZsGCBSxatAhPT0/CwsIICwsjIUGlLiR3Gc7OOP3jKXD3SFtYOzwM69aVpP57Kly54Ojw8gzD1R2jUj3w9IXUVEyVXhMREbml0NBQzp45w9QpU0g4c4SvXhvAl4O689VrA0g4c4SpU6Zw7uxZJeNF7oFh5Ey7G+PHj6dhw4Z4enoSEBBAp06dOHr0qN2YGzduMHjwYPz8/ChSpAhdu3bl8mX79SXOnj3LP//5Tzw8PAgICOCVV14h5Q7lrnKSEvIikq+sW7eOgPIhdHyqD4aLK6+Mm0D/WUvpOfFzCgVXZcTIkQSVLcu0adO4du0a7du3d3TIIn/LrFmziI6Opnnz5pQoUcLWFi9e7OjQpAAyylTEaPQoYEChwmmlV5ydobCno0PLUwwXN4yK9TGqNdGdBSIiInfg4+PDsGHDOHrkd8LDwzl16hTh4eEcPfI7w4YNw9vb29Ehisg92rp1K4MHD2bXrl2sX7+e5ORk2rRpw/Xr121jhg8fzvfff8+SJUvYunUrFy9epEuXLrb+1NRU/vnPf5KUlMSOHTuYN28ec+fO5a233nLEKQFgmAVo2k1MTAze3t5ER0erXq5IPrRu3Trat29PxSYt6Dp6GsNq+mICcy652MbEhl9m+bjhHN2+ga5du7JkyRLHBSz3rYL2flHQzldylpmcROqCqXD6aNpseWdncC+M03NvYbi5Ozo8EfkbCtr7RUE7XxERuTf57f0i/XyW+wZS2JK9c7mvW610ibx8z6/V1atXCQgIYOvWrTRr1ozo6Gj8/f1ZtGgR3bp1A+DIkSNUrVqVnTt30rhxY9auXUv79u25ePEigYGBAHzyySe8+uqrXL16FVdX12w9x6zQDHkRyReioqLo3qMHFZu0oNeU+RQpFkhkMjhhUtT5z+8dPYsF0n3cLAyLhTVr19rK14iISPYwXFxx+kcvKBGE0fQf4FYIblwnddZozEtnHR2eiIiIiIg4WExMjF1LTEzM0n7R0dEAtrUAf/nlF5KTk2ndurVtTJUqVQgKCmLnzp0A7Ny5k5o1a9qS8ZBW7iomJobDhw9n1yndFSXkRSRfmDdvHvHx8XQZPQ0n57T1qn+OdgLgQe9Uu7GHN31PySq1SExMZP78+bkeq4hIfmcElsb5+XdwevifOA0dj6VRa0hNJXXRv7D+vFZ10UVERERE7nMWjBxpAGXKlMHb29vWxo8ff8d4rFYrL730Eg899BA1atQAICwsDFdXV3x8fOzGBgYGEhYWZhtzczI+vT+9zxGcHfKsIiLZyDRNZn48i+ot2+NZ7M9fsleTDawYBLqagEn6+uB7vl1Eo259ObZjEzNmfszQoUNVo1dEJIcYhoHRrANGxZqkLp6JdccPsG87TgNGq4SNiIiIiEgBdO7cObuSNW5ubnfcZ/DgwRw6dIjt27fnZGi5QjPkRSTPi4iI4NgfR6nR6q8LtBqcSEhLtDvdtPWFuWto0LEn1Vu159gfR4mMjMy1WEVECiqjZDBOL7wDroUgIS6thE2YStiIiIiIiNyPjBxqAF5eXnbtTgn5IUOGsGrVKjZv3kzp0qVt24sXL05SUlKGcsSXL1+mePHitjGXL1/O0J/e5whKyItInhcXFwdAIS+fDH1bo5z56rIzqWScAZ8+PjY2NifDExGR/zHcPXAaNh7LA63SStgsVAkbEREREZH7kWHkTLsbpmkyZMgQVqxYwaZNmyhXrpxdf/369XFxcWHjxo22bUePHuXs2bM0adIEgCZNmnDw4EGuXLliG7N+/Xq8vLyoVq3avb9Af4NK1ohInlekSBEAEmKiMu1PsGb+Gz99vKenZ06EJSIimTAMA+ORx9JK2HzzcVoJm/0/4zTgTQxXlbAREREREZE0gwcPZtGiRXz33Xd4enraar57e3tTqFAhvL296d+/Py+//DK+vr54eXkxdOhQmjRpQuPGjQFo06YN1apV4+mnn2bSpEmEhYXx5ptvMnjw4CyVyskJmiEvInmen58flSqHcGjjqrva7/DGVVSqHGJbnVtERHKPUarcnyVs4mNJ/Xg0Ztg5R4clIiIiIiLkbMmarJo1axbR0dE0b96cEiVK2NrixYttY6ZNm0b79u3p2rUrzZo1o3jx4ixfvtzW7+TkxKpVq3BycqJJkyb06tWL3r17M3bs2Lt/UbKJZsiLSJ5nGAaDB73AiJEjiQ2/bLew663EXA3j8ObVTJ0yRQu6iog4SHoJG3PrSqy/bCV14TQsTUIxmrTR72YRERERkQIuK6Ut3d3dmTlzJjNnzrzlmLJly7JmzZrsDO1v0Qx5EckX+vTpg4eHB8vHDSc1JeW2Y1NTUvj23Zfx8PCgd+/euRShiIhkxjAMLM074vTEELA4Yf15DamzxmAm3XB0aCIiIiIiBZaRQ/+JEvIikk/4+Piw5JtvOL5zMwtG9Cbmalim42KuhrFgRG+O7dzM0iVL8PHxyd1ARUQkU0ap8n+WsLkenVbC5vJ5R4clIiIiIiKSrVSyRkTyjdDQUFatWkX3Hj2Y9M+6VG/xT6q3ak8hLx8SYqI4vHEVhzevxsPDg9WrV9OmTRtHhywiIjexlbDZ8h3WvdtIXTAVy4OhGI1VwkZEREREJDdZjLSW3ccUJeRFJJ8JDQ3l7JkzzJ8/nxkzP+ar176z9VWqHMLUKVPo06cP3t7eDoxSRERuxTAMjBadMCrVInXJLKzb18D+HTj1fwPD1c3R4YmIiIiIiPwtKlkjIvmOj48Pw4YN4+iR3wkPD+fUqVOEh4dz9MjvDBs2TMl4EZE8wCh9UwmbuCiVsBERERERyUVGDjVRQl5E8jHDMPDz8yM4OBg/Pz+VOxARyWPSS9hYGjSH1BRSF0zFums9pmk6OjQRERERkXxNCfmco4S8iIiIiNy3DMPA0qIzTo8PBosT1p9WkfrZWMykREeHJiL3sfHjx9OwYUM8PT0JCAigU6dOHD161NFhiYiIiCghLyIiIiL3P6N0BZye/18Jm5hIlbARkdvaunUrgwcPZteuXaxfv57k5GTatGnD9evXHR2aiIhInmDk0H+iRV1FREREJI8wCnngNPR9zC3fYt23ndQFU7E81A6jUWuVJRMROz/88IPd47lz5xIQEMAvv/xCs2bNHBSViIiIiGbIi4iIiEgeYlgsWFp2wanHIJWwEZEsi46OBsDX1/eWYxITE4mJibFrIiIiBZVh5EwTJeRFREREJA8yylT8s4RN9P9K2Fy96OiwROQ+ZLVaeemll3jooYeoUaPGLceNHz8eb29vWytTpkwuRikiIiIFhRLyIiIiIpInpZewsdRrBinJpM6fjPU/GzBN09Ghich9ZPDgwRw6dIivv/76tuNef/11oqOjbe3cuXO5FKGIiMj9x5JDTfQ6iIiIiEgeZlgsWFp3xenxwWklbLZ9T+rscSphIyIADBkyhFWrVrF582ZKly5927Fubm54eXnZNREREZHspoS8iIiIiOR5aSVs3k4rYRMVoRI2IgWcaZoMGTKEFStWsGnTJsqVK+fokERERPIUI4ea5KGE/Pjx42nYsCGenp4EBATQqVMnjh496uiwREREROQ+YRQq/L8SNg//WcLmvxtVwkakABo8eDALFixg0aJFeHp6EhYWRlhYGAkJCY4OTUREJG8wDIxsblrVNU2eSchv3bqVwYMHs2vXLtavX09ycjJt2rTh+vXrjg5NRERERO4TaSVsuv1ZwmbrSlI/fw8zOcnRoYlILpo1axbR0dE0b96cEiVK2NrixYsdHZqIiIgUcM6ODiCrfvjhB7vHc+fOJSAggF9++YVmzZo5KCoRERERuR+ll7BJ/WwcXLtK6sw3cXrqJQz/ko4OTURyge6MERER+XtyosSM5senyTMz5P8qOjoaAF9f31uOSUxMJCYmxq6JiIiISMGQXsLGqNv0fyVspmDdvdnRYYmIiIiISAGWJxPyVquVl156iYceeogaNWrcctz48ePx9va2tTJlyuRilCIiIiLiaIbFgtOj3XHq/gJYLFi3fEeKStiIiIiIiNyWFnXNOXkyIT948GAOHTrE119/fdtxr7/+OtHR0bZ27ty5XIpQRERERO4nRtnKOA0cA67uEHmF1JlvYoZfcnRYIiIiIiJSwOS5hPyQIUNYtWoVmzdvpnTp0rcd6+bmhpeXl10TERERkYLJ8CiSVsKmzkNpJWzmTVYJGxERERGRTBiGkSNN8lBC3jRNhgwZwooVK9i0aRPlypVzdEgiIiIikscYFgtObXrYl7D54n2VsBERERERuYnFyJkmeSghP3jwYBYsWMCiRYvw9PQkLCyMsLAwEhISHB2aiIiIiOQxdiVsIi7/r4RNmKPDEhERERGRfC7PJORnzZpFdHQ0zZs3p0SJEra2ePFiR4cmIiIiInmQrYRN7Qf/V8LmA6y/bHV0WCIiIiIiDmdYjBxpAs6ODiCrTNN0dAgiIiIiks8YFgtOoY9jhtQhdcXnWDetwLp/B069R2C4uDo6PBERERERyWfyzAx5EREREZGcYgSH3FTCJiythE2EStiIiIiISMFkGDnTRAl5ERERERHgphI2tZqklbCZqxI2IiIiIiKSvZSQFxERERH5H8NiwantEzh1GwgWC9ZNK0j5cgJmcpKjQxMRERERyTWaIZ9zlJAXEREREfkLI7jKnyVswi/9r4TNZUeHJSIiIiIieZwS8iIiIiJ/MWzYMIKDgzEMg/3799u2Hzt2jAcffJDKlSvTsGFDDh8+7LggJcf9WcKm8f9K2EzCunebo8MSEREREclxhmHkSBMl5EVERKSAM02T8PBwTp8+TXh4OKZp0q1bN7Zv307ZsmXtxg4cOJDnnnuOP/74g1dffZW+ffs6JmjJNWklbJ7EqetAsBhYNy4nZe5ElbARERERkXxNJWtyjhLyIiIiUiBFRUUxffp0QqpUxd/fn3LlyuHv709Ilars27ePIkWK2I2/cuUKe/bsoVevXgB07dqVc+fOcfz4cUeEL7nMKFcFp4Fvp5WwuXJRJWxEREREROSeKCEvIiIiBc66desIKluWESNHUii4Kj0nfk7/WUvpOfFzCgVXZcTIkQSVLUtCQoJtn3PnzlGiRAmcnZ2BtFs4g4KCOHv2rKNOQ3KZrYRNzUZpJWzmTcK676e7Pk5wcDAhISHUqVOHOnXqsHjx4hyIVkRERETk3qlkTc5xdnQAIiIiIrlp3bp1tG/fnopNWtBl9DQ8iwXa9dd8tCOx4ZdZPm44R35az44dO6hTp45jgpX7jmGx4NSuJ2ZIHVK/+xLrhmVYf92F01MvYTi7ZBhvmiYRERHExcVRpEgR/Pz8AFi8eLH+XomIiIiIFECaIS8iIiIFRlRUFN179KBikxb0mjI/QzI+nWexQHpNmY+zmzuvjBpFVFQUZcqU4dKlS6SkpABpidazZ88SFBSUm6cg9wmjfDWcnhuTVsLm8nlSZ/wfZuQVW//tSiLFxMQQGxvrwOhFRERERG5PNeRzjhLyIiIiUmDMmzeP+Ph4uoyehpPz7W8UdHJ2prCPLzdu3GD+/PkEBARQr149FixYAMCyZcsoXbo0FStWzI3Q5T5kFPZMK2FT44G0EjZzJ2Ldt/2OJZGuXbtG8+bNKVeuHP379+fq1auOPhUREREREcklhmmapqODyC0xMTF4e3sTHR2Nl5eXo8MRyRNM01SNLylwCtr7RUE5X9M0CalSlULBVXlywuzbjl3x7giObF9PXMQVLE7OGKaVxMRE/vjjD/r27UtERAReXl7MmTOHmjVr5tIZyP3MPPkbqd99yfXoaDb8+jvvRHjQ4c2MJZEAzv+2n42fTuLYjk106dKFuLg41qxZ44CoRe5OQXm/SFfQzldERO5Nfnu/SD+f3eWCKWLJ3rnccVYrDU+dzjev1b1SDXkRuSXTNLHu+RFSkjH8y2D4lQDvYhjZ/AtZRCQ3REREcOyPo/Ts/0qGPg+LlQeLJLH7uivRqRY6vznF1vfrj9/y1WsDiIyMJCQkhJ07d+Zm2JJHGOWrEff4S5x481nqlC7O2gZBfOfuTEwmY0tXq0OvKfNZMKI3a9auRV97i4iIiMj9JidKzGi+Zxpl1UTk9gwLXDmH+dtOrDu+x7r5a8yEOEdHJSJy1+Li0n53FfLyydDnakCwWyqdiyZgwf7mwfTxqvktdzJvyTIa/3sj50Oa4mxNocu2WVQ5s8duTFLCdRJio3Fydqbzm1OJj48nMDDztQxERERERCT/0Qx5EbklwzCw1GyKNfYaxEVBajIkWeBGPBQq4ujwRETuSpEiab+3EmKiMvRFpVo4lehEefcUQn1usDaqkK0vfbynp2duhCl5lGmazPx4FtVatmfng704f/kPWu5dwoOHVlP53F5WN+lHqpMLcRFXWfBKP8xUKyYmnn4BpFpNlYgTERERkfuKgZHtn08N3RsKaIa8iNyB4VYIS53m4OKadm+RxYJ1z4+YV845OjQRkbvi5+dHpcohHNq4KtP+TTFuJFsNSrmkUs4txbb98MZVVKocgq+vb26FKnlQekmkGq3aA3AusDLftHyRZGdXikVfotK5/QD4lg5m2FebefGbrbz0zTb+OWIcp0+dJDIy0oHRi4iIiIhIblFCXkTuyCgagKVmU4wKtTEq1QXTxLpvM6k7vsdMTbnzAURE7gOGYTB40Asc3rSK2PDLGfpNDJZGFsKKQXOvRApZrMRcDePw5tUMGTxIs5fltjIriZTgVoR/t3mVjfV7cDawcqb7qSSSiIiIiNyPDEvONFFCXkSyyChVEUu1xljK18LSrAs4OUFsJNZNX2NGhjk6PBGRLOnTpw8eHh4sHzec1JSMXyjGWS3sjHXFCZPuReP57r0ReHh40Lt3bwdEK3nJLUsiGRbOFK9KfCHvTPdTSSQRERERkYJFCXkRuWuGe2EsrXpilKuZNlt+94+k7vkR05rq6NBERG7Lx8eHJd98w/Gdm1kwojcxVzN+ofj7DRfCE5JJjAijS/3KLF2yBB8fn9wPVvKUO5VEuhWVRBIRERGR+5KRVkM+Oxu66xhQQl5E7pFhGFgq18PStGPabPmIS1g3fo0ZHe7o0EREbis0NJRVq1Zx4cB/mPTPunz16rP8+uO3HNu1hV9//JavXn2WhvXqERsdxagXB/Noi0ccHbLkAXcqiZQZlUQSERERESl4lJAXkb/F8PBKmy1fujKYqVh3rcF6YBumaXV0aCIitxQaGsrZM2eYOmUKCWeO8NVrA/hyUHe+em0ACWeO8N5771GudkOKFC4CMeH6nSZZcqeSSDdLTUnh23dfVkkkEREREbkvpU9oz+4mSsiLSDYwDANL9SZYmnQAixPmpVNYN3yFGRfl6NBERG7Jx8eHYcOGcfTI74SHh3Pq1CnCw8M5euR3hg0bhmdRPyhUBEwrXMvajGcp2LJSEgnSZsYvGNGbYzs3qySSiIiIiNyX0hLo2V22xtFndX9wdnQAIpJ/GJ5FsbR+EvPANszLZ7Hu+B6jdCWMqo10K76I3LcMw8DPzw8/P7+MnR7ecOM6WFMwE+LA2QWcnDEsTrkfqOQJ6SWRuvfowaR/1qV6i39SvVV7Cnn5kBATxeGNqzi8eTUeHh6sXr2aNm3aODpkERERERHJRZohL/nSsGHDCA4OxjAM9u/fb9t+7NgxHnzwQSpXrkzDhg05fPiw44LMpwzDgqVOcyyN2oFhwTx7FOvGRZjxsY4OTUTkrhmGAUWLp00PuR4FUVcg+iqmaTo6NLmP3akk0tQpUzh39qyS8SIi2UjXgAVTcHAwISEh1KlThzp16rB48WJHhySSb6hkTc5RQl7yPNM0CQ8P5/Tp04SHh2OaJt26dWP79u2ULVvWbuzAgQN57rnn+OOPP3j11Vfp27evY4IuAAwffyytngDf4pCainX7t1iP7VMSS0TyHtMEwwmsqYAJKcmQevv64CJ3Konk7e3t6BBFRPK0v14Hdu3aVdeA+Vxm1/4AixcvZv/+/ezfv5/HH3/cwVGKiNyZEvKSZ0VFRTF9+nRCqlTF39+fcuXK4e/vT0iVquzbt48iRYrYjb9y5Qp79uyhV69eAHTt2pVz585x/PhxR4RfIBgWJ5weCMXSoDUYBuaJX9Nmy9+Id3RoIiJZl5ryZwLesABWSL7h0JAk70gviRQcHIyfn59KuImI/E23ug4c8NxAli1bhtX650LsugbMH2537R8TE0NsrO7GFskJFsPIkSaqIS951Lp16+jeowfx8fFUb9menv1fsdVmPbRxFSNGjmT0W29RyN3dts+5c+coUaIEzs5pf+0NwyAoKIizZ89SsWJFR51KgWD4lcTS8gmsu1ZDXDTWbcswKtfDKFtNiQkRuf+5uIGnL8RdAzMVTCAxHgp5OjoyERGRAiUr14HW1FR27NhBnTp1dA2YD9zpZ37tj6M0b96coKAgWrZsyYQJE/D393d02CIit6WEvOQ569ato3379lRs0oIuo6fhWSzQrr/mox2JDb/M8nHDOfLTetuHMXEsw8kZp4c6pi32+us2zKN7MI8fwNKsC4ar+50PICK3tG3bNj744AN++eUXLl26xIoVK+jUqZOjw8o3DMMA98KYzq4QFwlJNyAlCTM1BcNJH6VEJPcNGzaMlStXcubMGfbt22f7rHur7SL5QVavAyd1aMCwYcOoUKECxYoVc1C0kh2y8jN/uPdgNn46iWM7NhEbG0ufPn1Ys2aNgyIWyV9youa75mSmUckayVOioqLo3qMHFZu0oNeU+RnekNN5Fguk15T5OLu588qoUURFRVGmTBkuXbpESkpa2QHTNDl79ixBQUG5eQoFnhEYhKVFD3ArBKnJWLcswbygW0ZF/o7r169Tu3ZtZs6c6ehQ8jXD2QW8A6Cwd1pNea2JISK54G7WS7rVdpG87m6uA4v4FqNMrYZ079EDLy8vXQPmUVn9mZeuVodeU+ZT6cGWrFm7lp9++imXIxXJvwzDyJEmSshLHjNv3jzi4+PpMnoaTs63n5Xo5OxMYR9fbty4wfz58wkICKBevXosWLAAgGXLllG6dGndqugAhrMrTs17YKnxEGBgPfQzqZsWYyYnOTo0kTypXbt2vPvuu3Tu3NnRoeR7hmFgFPYB3xJpCXoRkRxyt+slATRr1ozSpUs7IFqRnHU314Fg0HLACOLj41m7dq2uAfOorPzMkxKukxAbjZOzM53fnEp8fDyBgZkn7kVE7ie6z1ryDNM0mfnxLKq3bH/Lb8fTrXh3BEe2rycu4goWJ2dGjhzJ0KFD+fTTT+nbty/vv/8+Xl5ezJkzJ5eil8wYpSpi8S+NddtySL6Bdcs3WGo+jFH87md1BQcH4+bmRqFChQB4/fXXefzxx7M7ZBERAM3sEJEcdS/rJYnkV1m9Drz5GvCbNwfh5OLGjJkfs/K7b+nXr5+uAfOQrP7M4yKusuCVfpipVkxMPP0CSLWamKapz2oi2UAla3KOEvKSZ0RERHDsj6P07P9Khj43Ugky4jhtepKMhc5vTrH1/frjt3z12gAiIyMJCQlh586duRm23IHh6o5T655Yz/yGefQXrAe2wnEvLE3a37I2s2maREREEBcXR5EiRfDz8wNg8eLFqpUqkgWJiYkkJibaHsfExDgwGhERuZnWSxKxd7vrwEKGlVQMkkzD7hoQ/rwO9Pf31zVgHnO7n3mFiGO4pSbym391fEsHM+yrzba+m6/9068RRUT+jt9//52vv/6an376iTNnzhAfH4+/vz9169YlNDSUrl274ubmdtfHVckayTPi4uIAKOTlk6HPnxs0tVzhKacTNDKuYvBnXd/08bGxsbkRptwjS9lqWB7pCk7OcD0a66avMcMv2o253a3bMTEx+hmLZNH48ePx9va2tTJlyjg6JBER4e+tlySSX93uOvCfPvH09Mv8GkDXgXnX7X7m1a4epvG5Hfzzj+8zrOejn7lI9kqfIZ/dLS/Yu3cvrVu3pm7dumzfvp1GjRrx0ksvMW7cOHr16oVpmvzf//0fJUuWZOLEiXYT3rJCM+Qlz0ivk5kQE5Wh7zwe7LL608gSTnXLNaoSzS5rMY6Y3rbxnp6euRit3AvDzQNLqycxT/yKefJXrL9sAB9/LA3b8OP6Dbe9dfvaH0dp3rw5QUFBtGzZkgkTJuDv7+/oUxK5L73++uu8/PLLtscxMTFKyouI3AfuZb2k2PDLzJ8/n2HDhuVSlCK563bXgYUtJk4AmIB9lkfXgXnX7X7mP1T6B08eXEjxuEv0+nUei2o+jdXiZDdeP3MR+bu6du3KK6+8wtKlS/Hx8bnluJ07dzJ9+nSmTJnCG2+8keXjG6b5l68U87GYmBi8vb2Jjo7Gy8vL0eHIXTJNk5AqVSkUXJUnJ8zOdIwFk0bGVUIs0VgwScXCqzPmsWvrZo4e+V115PIQMyEO68/fQWoKsdfjaf3qBK6XCMn01m2A87/tZ+Onkzi2YxNdunQhLi6ONWvWOCByyQ/y8vuFYRisWLGCTp06ZXmfvHy+IiL5RVY+66b763pJhmklMTGR559/ntWrVxMWFoafnx+enp4cP34822IsaO8XBe1871e3+7fR0ec6xZxT+TqyCNet9gUAvnr1WRLOHNF1YB50p9+HFmsqTxxaSKHkBJKdXPmq5lNp/6+fuThIfnu/SD+fI7Ur4enklK3Hjk1NpcqBY/f9a5WcnIyLi0uOjVfJGskzDMNg8KAXOLxpFbHhlzMdY8VgpxnAwtTyXDI9ICWZV//ZmG1zpkLSjVyOWP4Oo1ARLK16khhQjvPnzrJw5LPM+78X8fLLfNZ76Wp16DVlPpUebMmatWv56aefcjliEceJi4tj//797N+/H4BTp06xf/9+zp4969jAREQky9JrJtdo1T5DnxMm3k5W+F9Zxs5vTuH1H37lvd1hdB87g+TkZCIjI/n00085f/48KSkpXL58OVuT8SKOcrvrwHNJaXeS+DhZ7bbHXA3j8ObVDBk8SInZPOhO1/5WixOLaj7NRc9SOKcm8+TBBaReOqWfuYhkm7tJrt/LeCXkJU/p06cPHh4eLB83nNSUlFuOS8aJVUnF6TF6KrHXE/ArWhTzzEGsJ/djpiTnYsTydxiGwext++g86Us8/EsSfOMyT59fi29StN24pITrJMRG4+TsTOc3pxIfH09gYOY1V0Xyoz179lC3bl3q1q0LwMsvv0zdunV56623HByZiIhk1e1qJpdzS6Fb0et0LhqPBdVMloLnVteBl5LTZm6Wcv1zW2pKCt+++zIeHh707t0712OV7HHHa3/DYG3l9vzuXw2n1BQ6751L9dLF9TMXyUYFuYZ8VuzZs4dt27bd075KyEue4uPjw5JvvuH4zs0sGNGbmKthmY6LuRrGghG92fXjKmKKlce5XC0wLJCShHlyH9YLf2BaU3M5erlbpmky8+NZeNR4kIXBj3GicGmcTCsdw7bRNGK/bRGfuIirzH6uE9N7PMKXg3vg6RdAqtWkAFXkkgKuefPmmKaZoc2dO9fRoYmISBbdrmby2SRnUkwo5myld7E4PCx/zgZWzWQpCG51HRiVkpbSKP2/hHz6deCxnZtZumTJbev+yv0tq9f+6wpVZOrW/aTeiGfb6/3xvhGd6TgRuXsWw8iRll88/fTTtGjR4p72VQ15yZPWrVv35wKfLf5J9VbtbQt8Ht64isObV+Ph4cHSJUto06aNbT8z7hrmpRNgWgEDo2hxKFZat7Tdp8LDw/H396fnxM+p+WhHAPySovjn5Z9xNlO57uTO4lJtMuz364/f8tVrAwgPD8fPzy+3w5Z8oKC9XxS08xURuR/dqWaygcmjXgkEuaWSasIP0YW4lOycqzWTC9r7RUE737wgs+vADzo3JjEpmc4vv3PL60DJu7J67b9x3ifUi78AmFgat8MoX8PRoUsBkt/eL9LP51jdyjlSQ77Svj/yxWt18eJFkpOTKVu27F3v65wD8YjkuNDQUM6eOcP8+fOZMfNjvnrtO1tfpcohTJ0yhT59+uDt7W23n1GkKFSsD9fCMCPOY167BFFhEBAMXsWUmL/PZHbrdoSrDwtKt6Nl+G5SDKe0WfJ/+bndfOu2EvIiIiKSF6TXTB4xciSx4ZczLGJvYvBjjAdV3JN4sEgi//BOYNeVGxzevJqpU6boc6wUCJldB75SfyUWi4WEM0dueR0oedfdXPub4Zewrl+EdecajNgoLLWbOjBykbwvJ0rM5KePKyVLlrznfTVDXvI80zSJjIwkNjYWT09PfH19s3RBYlqtmFfPQHQ4YIJhwShVGcNDfzfuF5nNkM8KzZCXv6ugvV8UtPMVEblfRUVFEVS2LKVqN6LXlPk4OWc+f8rPOZUO3tdJCA/j9yNHeLBdZ3yKFs3x+Ara+0VBO9+8Jv06sHDiNZwsFpwDgjEsqsqbn2Xl2t+Mi8K66gtISYGyVbA0fUxfWEqOy2/vF+nnc7xezsyQr7g3b82QP3v27G37g4KC7vqYereSPM8wDPz8/AgODsbPzy/Lb7aGxYIlsBxGhbrgXhhMK+b5I1iP7cFMSsjhqCUr/Pz8qFQ5hEMbV93Vfoc3rqJS5RB8fX1zKDIRERGR7JfVmsmnLl2l/YCXiIwI55GHmuCdGoeZmsmihyL5WPp1oFthL5ydnEBrhOV7Wbn2N4r4YOk8CJxd4MwRrKu/xLRaMzmaiNyJYRg50vKa4OBgypUrd8t2L1SyRgo8w8kZI6g6ZnIi5umDaYn50wcxXd0xSoVgxoRjeHhhFNJCWbntTrduZybmaphu3RYREZE8KzQ0lFWrVtG9Rw8m/bPubWsmR5hD8PDxg6QbcO0Sppc/hqu7o09BJHe5ukNSAqQmpSVhpcAz3Aph6TYU67IZEHUV65LpWLoOwdDfDxG5B/v27bN7nJyczL59+5g6dSrvvffePR1TJWtE/sJMiMM8f+R/C78CqSng7IpRpgqGexHHBlcAZfXWbYDUlBQWjujN+QP/4eyZM/j4+OReoJKvFLT3i4J2viIieUFUVJStZvKxP47atleqHMKQwYPs6mSbCXEQF5k2wMMLPLzTZgsblmwt4VHQ3i8K2vnmVWZyYtq6YO5FMDxVrlL+ZFqtaeVrYiLB2QVL5xcw3Ao5OizJh/Lb+0X6+ZysH4KnczaXrElJpfwvR/PFa7V69Wo++OADtmzZctf7qmSNyF8YhYpgVKyPEVA2bcFQ0wrJiZjnj6qUjQNk9dbtmKthLBjRm2M7N7N0yRIl40VERCRP8/HxYdiwYRw98jvh4eGcOnWK8PBwjh75nWHDhtktWmkUKgJFi6etlBYfA5EX01rUZQrQ/KsMtm3bRocOHShZsiSGYfDtt986OiTJCU7/m/WsazX5C8NiwdLhWShTGVKSsa6YhRkX7eiwRPIMlay5vZCQEHbv3n1P+6pkjUgmDMPA9PAGAzAsaYn5xPi0mfNla2A46Va33HQ3t26vXr2aNm3aODpkERERkWyRXjP5TgvVG86umL6lIPICWFPAak2bWBIfDYV9cifY+8z169epXbs2zzzzDF26dHF0OJJTkm+k/b9pxYy5Cp5+GMa9zz20RoZhuLhieGo9qvzAMAycHumMdf82zMO7sH7/OZY2T2H4FXd0aCKSR8TExNg9Nk2TS5cu8fbbb1OpUqV7OqYS8iK3YLi6Q3BtSIyHpATMxHhITQWL/tk4QmhoKGfPnLHduv3Va9/Z+ipVDmHqlCl2t26LiIiIFDSGxYLp4gY3rqd9ZjWtEB+D6eaB4ezq6PByXbt27WjXrp2jw5AcZFqtEHP1fwu6mpBoBQ8fcL63hLyZmop5+lfMlGTwLY6lZGUMD60llh9Y6jTD9CyK9T8/YF23AEuzThilKzo6LJH7m5F28112HzOv8fHxyTCz3zRNypQpw9dff31Px8xTmcVt27bxwQcf8Msvv3Dp0iVWrFhBp06dHB2W5GOGq3vaIkHkyd8Z+U76rdtDhw4lMjKS2NhYPD098fX1zVe3PYmIiIjcMydnsFjATAWTtKR8bCSmT6A+L91BYmIiiYmJtsd/nREn9x/DYsF0LQSJ1wFL2t3NTvee5jCcnDCKlca88AeEX8B67TL4B2EpHaIFQfMBo0JNLB6eWDcvxbptBUb9VlhC6jk6LBG5z23evNnuscViwd/fn4oVK+J8m3UObydPJeR1y6GIQNZv3RYREREpaIwivpiFvNLu8rwRBynJkJyY9ti9sKPDu6+NHz+ed955x9FhyN3y8Iak+LQyTU5uf/uLJyMgGPPyGcBMu0P6ymnwLQFeuvbID4wSwVja9cH6w3zMPRuwxl7D0qCVo8MSuS/lRM33vDg54JFHHsn2Y+apRV3btWvHu+++S+fOnR0dioiIiIiIyH3JcHLG8PCCoiXSFnst7A1uhRwd1n3v9ddfJzo62tbOnTvn6JAkCwwXN3D1SHuQDaWZDHcP8CuZ9mUWZtoxC6lsTX5iFPXH0vE5cHLGPLKH1A2LMU2ro8MSkTzm0qVLnD179p72zVMJ+buVmJhITEyMXRMRERERESkIDMPAcHHDKOzztxa5LCjc3Nzw8vKya5JHeHinlarJprUSLIHBaUn4wt5gtWI9uBUzNSVbji33B8PDE0uXQWl/Z8JOYV0+CzM11dFhidxXDEvOtPyiZcuWlCtX7p72zUcvQ0bjx4/H29vb1sqUKePokEREREREREQkGxkubuBXBiObZrIbhb2x1G6BpUYzDL+SYE3BemBz2iKykm8Yru5Yug8FFzdIiMW69EPM5CRHhyUiecT8+fPZtGnTPe2brxPyuuVQRERE5PbmzJmDYRh8++23jg5FRCRbxcXFsX//fvbv3w/AqVOn2L9//z3fXi73t5yoc2wYBkZwTfD0S0vK79+IaZrZ+jziWIaTM5YeL0KxUpCchHXZDMyE644OS+S+YPs9mM0tv2jYsOE915fP1wl53XIoIiIicmunT59m9uzZNG7c2NGhiIhkuz179lC3bl3q1q0LwMsvv0zdunV56623HByZ5CWGYWCp3DBtUeTUFKy/blFSPp8xDAuW0F4YFWun/Yy//QQzJsLRYYk4nsXImSb5OyEvIiIiImCaJuHh4Zw+fZrw8HBM08RqtfLss8/y0Ucf4ebm5ugQRUSyXfPmzTFNM0ObO3euo0OTPMYwDCzVHwZnZ0i+gfX3nUrK5zOGYWBp3Baj7iNp6wasnoN55byjwxKR+0BqaiqTJ0/mgQceoHjx4vj6+tq1e5GnEvK65VBykmmamMmJ+mAlIiL5RlRUFNOnTyekSlX8/f0pV64c/v7+hFSpSufOnalfvz7169d3dJgiIiL3PcMwsNRuBRZniI/GemKfo0OSHGCp1ghL08fABOuGrzBP/+7okOQeDRs2jODgYAzDsOURb7ddMmEYOdPymHfeeYepU6fy+OOPEx0dzcsvv0yXLl2wWCy8/fbb93TMPJWQ1y2HkpPM69GYh7ZjHtiE9eA2rEf/i/XicUeHJSIick/WrVtHUNmyjBg5kkLBVek58XP6z1pKz4mfY/iVYuXKlXw8axbr1q1zdKgiIiJ5gmGxYKnTMi0pH3UF65nDjg5JcoBRNgTLo0+CYWD9eRXWQ7scHZLcQWZ3g3br1o3t27dTtmxZu7G32i73p23bttGhQwdKliyZ6bpXffv2zVCjvm3btnZjIiMjeeqpp/Dy8sLHx4f+/fsTFxeX5RgWLlzI7NmzGTFiBM7Ozjz55JN8/vnnvPXWW+zadW+/H5zvaS8HSb/lUCQnGC5umG6FIC4KLMmQEAvxsZiBwRhOeeqfioiIFHDr1q2jffv2VGzSgi6jp+FZLNCu/3pUJBeO/sqN63G0bdsWFxcXfvvtNy5dusQLL7zgoKhFRETuf4bFCUut5lh/3Yx59RxWFzcsJSs6OizJZoZ/KSz/fCatdM2BbVhjIjCa/CNfLUiZH0RFRTFv3jxmfjyLY38ctW2vVDmEwYNeoFatWhn2adasWW6GmKflxCKsd3u869evU7t2bZ555hm6dOmS6Zi2bdsyZ84c2+O/luN86qmnuHTpEuvXryc5OZl+/frx3HPPsWjRoizFEBYWRs2aNQEoUqQI0dHRALRv357Ro0ff1fmkU5ZR5H8Mt0JQqT7myQMQGwkYYIB56CfwLQklKygxLyIi972oqCi69+hBxSYt6DVlPk7OGd+7GnfvR+Pu/UhNSWHBiN4c27GJadOm8dRTTzkgYhERkbzFcHbBUrM51oNbMC8ex+rsiiUgyNFhSTYzvHyxdH4hbZHXk4cwo65iadcbw8hTxSbyrXXr1tG9Rw/i4+Op3rI9Pfu/QiEvHxJioji0cRUjRo5k9FtvUcjd3dGhyt/Qrl072rVrd9sxbm5uFC9ePNO+33//nR9++IHdu3fToEEDAD766CP+8Y9/MHnyZEqWLHnHGEqXLs2lS5cICgqiQoUK/Pjjj9SrV4/du3ff81pc+i0ichPDxQ2jYl3wCQA3d/D2B8CMOI95cBvWP3ZjJt1wcJQiIiK3Nm/ePOLj4+kyelqmyfibOTk70/nNqaSmprJ58+ZcilBERCTvM1xcsdR4GAwL5rnfMCMvOTokyQGGuweWrkPAxRUiw7B+Mx0zNcXRYRV46XeDlqrdiFfX7OfJCbOp+WhHKjZ6hJqPduTJCbN5dc1+StVuxJUrV9ixY4ejQ86bLEbONCAmJsauJSYm3nOYW7ZsISAggJCQEF544QUiIiJsfTt37sTHx8eWjAdo3bo1FouF//znP1k6fufOndm4cSMAQ4cOZfTo0VSqVInevXvzzDPP3FPMmu4r8heGkwuUr5P2Z4sF07RC+HnMiycgPgbzt58xLU4YFepiFPZ2bLAiIiI3MU2TmR/PonrL9hnK1IAJZLxF1Mu/OLUe7ci2n7ZjmqZuxRYREckiw7UQlmoPYv3tZ6ynfsXi7ILhVczRYUk2M1xcsXQfhvW7z+B6DNYlH2Hp8gKGq2ZeO0JW7gYF8CwWSK8p83n74XK8MmoUPXv2xMfbO08uKpoflSlTxu7xmDFj7mmB1LZt29KlSxfKlSvHiRMneOONN2jXrh07d+7EycmJsLAwAgIC7PZxdnbG19eXsLCwLD3HhAkTbH9+/PHHKVu2LDt27KBSpUp06NDhrmMGJeRFMmVY/rx5xDAs4B8ExcpA3DXMU7+CNRXz2B5MwwmjdGXwLaEEhoiIOFxERATH/jhKz/6vZOgLdrpBC/cofkjw5ZLV/tbK6q3a89Vr3xEZGYmfn19uhSsiIpLnGYWKYKnSGOuRXViP/YKlSiOMwj6ODkuymWFxwtLpeaybl8LFk1iXf4ylw7MYhb0cHVqBc7d3gxb28SU2/DKbf/yBzqH/W5TZ5X+fhbVO5e0ZRvZ/gfG/4507dw4vrz///dxr6ZcnnnjC9ueaNWtSq1YtKlSowJYtW2jVqtXfi/UWGjduTOPGjf/WMVSyRiSLDMP4f/buPD6q6v7/+OvcyTpkGTIJ+y4hIAKiVsRqFReiNRbFgq0LoVVqRaFfAbcWtVb7w1rBFbHaVqFUWrCINbGiIrhUXKogEGVTdkjIQjYCSWbm/P4YEo0JW0gyWd7Px+PW5C5nPjclufd+7jmfg4lNwBl8PmbAcIiIBhvA7vgSu2YFdtcmrN/foJ/5/PPP1zmLtIiISF1KS0sBiI7z1NpWbMMwWC6JLiDa1LxeVe1fUlLS2CGKiIi0OqZdPE7y6QAE1n+EPVAa4oikMRhjcF0wBnPymeD3Efj3c9h9e0MdVpty5NGgEOVYEsIsXSICvP3QFGZeOpjSvBziYmP51ZSp2ICfmyb9im59ktm5cyepqSPp21eTMh+OcUyjLABxcXE1lvom5L+rT58+JCYmsnnzZgA6derE3r01f099Ph8FBQWHrTsP8OGHHx7zZ5aVlZGVlXVccSohL1IPJtKNc/LZmFPOBU/wImBzt2PXvkNg06fYymOvfWWtJS8vj61bt5KXl4c99IZ269atPPfccyf81k1ERNqOmJgYAA4UF9baVhAIZ2V5PC4sY917cfimR1DV/rGxsU0RpoiISKtj4hJxeg8BLIEvPsCWHwh1SNJInNNGYL53MdgAgf/Mw+7eEuqQ2oyq0aCnXJhWa1s7x3JNRx+jkyr5odfHi48/xJer/0f2zu2s+99HvL7o79iA5U+PPsLOrM/w5e0i5+uNbN64IQRnIo1l586d5Ofn07lzZwCGDx9OYWEhn376afU+b7/9NoFAgGHDhh22neuvv57U1FQWLVrE/v3769zniy++4Ne//jUnnXRSjfaPhRLyIifAhIXj9DoFM+g8TOe+waE3+wuxWe8TWLMCW1Z82GMLCwt5/PHHSek/gKSkJHr37k1SUhIp/Qfw6KOPMn78eJ588skGe0soIiKtn9frJblfCuuWZdS5/UtfO3b5I4nAcnl0XvX6rGUZJPdLISEhoalCFRERaXVMQidM95ODidqs97CVFaEOSRqJ028oznmjAQiseAm7+fMQR9Q2HGk06P4AfFbisOmAw6clLlYUhpGRH8ZLueH88Z0vue03v8UfCAQnFY1sB7FeiGkPjquJz6IFqSpZ09DLcSgtLWX16tWsXr0agC1btrB69Wq2b99OaWkpt99+Ox9++CFbt25l2bJljBo1ir59+5KamgrAgAEDuOSSS5gwYQIff/wx//3vf7n11lv5yU9+QpcuXQ77uV988QWXXXYZ06dPx+PxMHDgQC6++GIuv/xyzjnnHBITEznttNPYsmULb7zxBuPGjTuu81INeZEGYBwHOvaEDj2gOB+7bV2wzvzGT4J15nv0B0/H6jrzS5cuZczYsZSVlTHwgjSuueF2ouM8HCguZN2yDKZOm0Z4WBh5eXlH+WQREZFvGGO4ZeLNTJ02jZK8nDqH8r5+MIFx7bJJcioZEl7Ke7tLyVqeyayZMzUfioiIyAlyOvQg4KvA7t5MYO0KnMEjMGHhoQ5LGoHpehLOJdcTWDqfwEdLMSX7cIaeH+qwWrUjjQYFw+rSupPre3NzeWP5O+x3IvHEecGof3JL8b///Y8RI0ZUfz9lyhQA0tPTmTNnDmvWrGHu3LkUFhbSpUsXRo4cyQMPPFCjc+vf//53br31Vi688EIcx+Gqq67iiSeeOOLnhoeHM3nyZCZPnsz//vc/3n//fbZt28aBAwcYMmQIt912GyNGjKh3hyZjbduZwaC4uJj4+HiKiopqTBwg0hjswf3Yr1ZBZQVgwTiYpB68uXYTl6VdTt/hIxh9z6O1kiXZm7/kpfsmEZOQyFcfvcOAAQP43e9+xxVXXBGS8xBpi9ra9aKtnW9rV1hYSI+ePek6ZBjXzZxX52RXkQS4pl0Oxlp++cAs3nr1ZbZv24bH42n6gEWkxWhr14u2dr7SsALbvsDmbgfHhXPqBRj1wm217P5iAq/+GXyV0K0vznmj1cmhkVhrSek/gOheA/jpQ88d83EL7ryRA9vWs2H9l43y/01ru15Unc+ui04jLrxh/3YVV/rp+tZnreZnVV96JSTSSExUO5yB5wTrzMcnARbfnq/pnL+Zvz9yPzc+8tc6ey5uXfUhxbl7yPl6A7jCWLt2LRMmTGDOnDlNfxIiItLieDweFi1cyOaVy5k/dRzFudm19inH4Z+7LUU5u7jvp5ey5F8vKRkvIiLSgJyeJ4OnAwR8BFa/jQ0EjvnY559/HmMMS5YsabwApcGYdnE4oydCWDjs3EzglWexAX+ow2qVqkaDZr2dQUlezjEdU5ybTdbyTG69ZaJelEizoYS8SCMzYeE4vQdjBp3Pext34PP5+MHpp3J94AuuLf+chEBZjf3PGvMzfv1GFndmruL2f38CwKhRo7j55ptDEb6IiLRAqampZGRksOvzj3j4sqEsuPNG1ryxhE0frmDNG0tYcOeNTLn4dB7981xO6tObESndaEODJqUF27RpE2effTb9+vXje9/7HllZWaEOSUTksJyThkI7z6Gk/LIa11prLXl5eWzdupW8vLzqbVu3buW5557jrLPOClHUUh8mIgpnzGQIj4DSfQQWPYH1VYY6rFYpPT0dt9vN4gduw+/zHXFfv8/Hkgen4Ha7j7vGt9Asasi3VkrIizQVY/jlbx9m/N/fYXlUP3w4ROLnisr1jCtfTQ9/Ya1D4pI60a69l9f+8x8lSkTqYH2V2PIDwRJRB0qxZcX6XRE5JDU1le3btjFr5kwObFvPgrsm8NeJY1hw1wQObFvPrJkzmfHkn2jXPhECAdi7LdQhi9RQV7Lqpptu4he/+AUbN27kzjvvZPz48aEOU0TksIwxOP3PgvAo8PsIrHuPwn37ePzxx0npP4CkpCR69+5NUlISKf0H8OijjzJ+/HiefPLJGvWPpWUwrjCcsb+C9h2hsoLAS09iD+zH7voKe7Ds6A3IMTmW0aAQ7Bk/f+o4Nq1czkuLFmk0aH04BCfBbdAl1CfVPOjHINJE8vPz2bRxA6dcmMY2l4d5kaeyJLw/5YQRRoALfFsIt7WHtf3ozofYs3s3BQUFIYhapHF8N8kyadIkevXqhTGmevZ0gMmTJ9e5HggOA927JbjkboO8bVCwCyp0sytSxePxMHnyZDas/5K8vDy2bNlCXl4eG9Z/yeTJk4mPj4eOvcFxoHw/tiQ/1CGLUFhYWGey6qS+yXzwwQekpaUBcNVVV7Fjxw42b94c4ohFRA7PGIMz+HxwhbG/IJfMJ37H1GnTiO41gGv+8GdumPMS1/zhz0T3GsDUadNYuXIleXl5oQ5b6skYB+eH4zG9B4KvksCSZwi8+SKBj5aGOrRW5VhGgz582VB2ff4RmZmZjBw5MtQhi9RQe5YvEWkUpaWlAETHearXFThu/h45mChbSYytoLKOd2RV+5eUlOD1epsiVJFGU1hYyNy5c5n99Bw2bdxQvb5bt+7ceOMN/OUvf6mx/49//GPuuOMOzjnnnBrrrd8HRTlgAxDwg3GCQ9/atYeI6CY5F5GWxBiD1+ut8zpijMF2SYbdG2FfDjbSjdHvkYTI0qVLGTN2LGVlZQy8II1rbrid6DgPB4oL+fjl+ZR//RV9TjqJRQsXkpqaSo8ePdi+fTt9+/YNdegiIodljGFZrp+EnV8xbNDJvP3G63zgGVJjn6Te/cjfsYWYhETS0tIYMGBAiKKVE2WMwXw/DX/JPtj1VfA5ZesX2H5DMZ17hTq8VqNqNOi8efN4avbTLLjrleptyf1SmDVzJunp6cEOKFIvxpgGr7vf0uv4Hzx4kKioqBNuRwl5kSYSExMDwIHiwlrbDppwDprwOo+r2j82NraxQhNpEkdKsqxblsEDDz5IwO/ngw8+4NRTTwXgBz/4QfXx1lrs/kIo2htMxANwqAad40D7TuD2tPgLvEgoGFcYNqlnsGxNzhZslxSMyxXqsKSNWbp0KWlpafQdPoLR9zxKbGLHGtsTuvbixZ1b6dA7mbS0NDIyMkIUqYjI8SksLOTHY6/mpDPOJuP+SfTnIL6KbXwc0bN6n62rPqQ4dw/7C/PBFcbatWuZMGECe/bs0XxiLVVlRfC5JSwyWMLms+U4l6ZjHBWraChVo0EnTZpEQUEBJSUlxMbGkpCQoOdCaTCBQIDf//73PPPMM+Tk5LBx40b69OnDPffcQ69evbjhhhuOu039FRBpIl6vl+R+KaxbdnwPj1nLMkjul0JCQkIjRSbS+KqSLF2HDOPO11bz04eeY9DFo+g77DwGXTyKnz70HHe+thpXRCSTJ09m6dJvhnTaioPg9wXL0hRmB29qjQMJXaFjH4j1QlJPTLv2uukSOQEmqh3EJ4K1sHuj5mOQJlVYWMiYsWPpO3wE182cVysZDxDfqQv79+Xx0z/8lb7DR/DjMWPYtm0bPXr0CEHEIiLHbu7cuZSVlfHDux7hn+7T8BmHUyqzGVS5u3qfs8b8jF+/kcWdmau4/d+fADBq1Cgl41sw59xRmMHfh/BIMEDODvh6bajDapWqRoP26tULr9er58KG0uD14w8tLcyDDz7ICy+8wMMPP0xERET1+lNOOYU///nP9WpTCXmRJmKM4ZaJN5P1dgYleTnHdExxbjZZyzO59ZaJuqBIi3UsSRaA2MSOxCQk0n3w9/j5z8ZzIHsbdtcGyN0KHEoMxiRA52RMl36Y6FhMWDimfWdMpLvJzkekVYtLCj40BgKQtyPU0UgbUpWsGn3Po7jC6h7EG5OQRJf+g1n7xstcOX0WZfv3ExkZqXI1ItKsWWuZ/fQcBl6QRmxiRypMGIuih+A3hjMqdpDsy611TFxSJ9q19/Laf/6jF+QtmPEk4pyZijN6Imb4D8GTiEXP9SItzbx583j22We59tprcX1rFPGQIUNYv359vdpUQl6kCaWnp+N2u1n8wG34fb4j7uv3+Vjy4BTcbjfjxo1roghFGt6xJFmCLGEGnrnn/3hj7mzKcncFV4dFgisM06EXJr4DxlEZDZHGYoyBTn2CZaAOlGBL94U6JGkDvpusOpIrfzOTj/41j2cnjCKyXSzGcSlZJSLNWn5+Pps2buCUC9Oq1x0wESyOGkzAGM6u2FLncT+68yH27N5NQUFBU4UqjcREuXFOHoZz5S9x+g4OdTgix86YxllamF27dtXZASQQCFBZWVmvNpWQF2lCHo+HRQsXsnnlcuZPHUdxbnad+xXnZjN/6jg2rVzOS4sW4fF4mjZQkQZyLEmWWOPjh+4Cfha7l2gTIDwsDCKiue+xZ4K94Tv2BvUkEWkyxjjQuW/wZrlgT7BslEgjqitZVSU84CM88E0nhqRefZk49z9MW/IRV/zmEbZv26pklYg0a6WlpQBEx3lqrC9xolgcNZi3I5LrPK5q/5KSksYMT5qQMUrBibREJ598Mu+9916t9S+99BJDhw6tV5ua1FWkiaWmppKRkcGYsWN5+LKhDBxxGQMvTKue3DJrWQZZyzNxu91kZmYycuTIUIcsUm9VSZZrbri91raU8AOcFVVCmLFMnX4/by1/l715eYwa/0swhtL8XEp8hmXLlpGdnU1qaiqxsbFs3rw5BGci0raYsHBsYo/g3A05W7Bd+2l0ijSawyWrANL2fYyD5V/e79fa9u1kldfrbcwQRUTqLSYmBoADxYW1tpU4UZQ4UXUeV7V/bGxsY4UmInJExgkuDd1mS3PvvfeSnp7Orl27CAQCLF68mA0bNjBv3jwyMo5vnsgqSsiLhEBqairbt21j3rx5PDX7aRbc9Ur1tuR+KcyaOZP09HTi4+NDGKXIiTt8ksXyvahSXFgOBBwuuPsxTr4jnKqe8Js+XMFfJ47h/vvvZ+7cuU0as4gEmegYbKwXSvJh10Zst/6az0QaxZGSVXH+ssOOkVKySkRaAq/XS3K/FNYty2DQxaOO+bisZRkk90shISGhEaMTETmCxigx0wKfJ0aNGsWrr77K7373O9q1a8e9997LaaedxquvvsrFF19crzaVkBcJEY/Hw+TJk5k0aRIFBQWUlJQQGxtLQkKCEh7Sahw+yWL4Z4mXAAZ/HakWJVlEmglPRygrBl8l5O/CRseA48JE63dTGo6SVSLSmhljuGXizUydNo2SvJyjzpUBwRKmWcszmTVzpp4NRUSagXPPPZc333yzwdprgQMFRFoXYwxer5devXrh9Xp1wyWtyreTLN9ViVNnMh6UZBFpLowxwXryjgNlRZC7A3J3YAP+UIcmrUhVsirr7QxK8nJqbLMYoPakrVXJqltvmah7JxFp9tLT03G73Sx+4Db8Pt8R9/X7fCx5cAput5tx48Y1UYQiIrUZxzTKIkrIi4hIIzpSkuVwlGQRaW4shEWA3xccYhrwQZkmmJOGdaRk1XevBEpWiUhL4/F4WLRwIZtXLmf+1HEU52bXuV9xbjbzp45j08rlvLRoER6Pp2kDFRERANq3b09CQsIxLfWhkjUiItKo0tPTuefee1n8wG1cN3MerrDDX3qUZBFphqyFyoOACc7CFAjA/kKI8YQ4MGlNqpJVaWlpzJ86jiunzyIuqVOt/Ypzs3n5wSlsXrmczMxMJatEpMVITU0lIyODMWPH8vBlQxk44jIGXphGdJyHA8WFZC3LIGt5Jm63m8zMTEaOHBnqkEWkrWvDNeQfe+yx6q/z8/N58MEHSU1NZfjw4QCsXLmSpUuXcs8999SrfWOtrT0GtJUqLi4mPj6eoqIi4uLiQh2OiEibsXTpUtLS0ug7fMQxJ1lC+RDS1q4Xbe185fjZigNQsBsO7g8m6B0XdO2HCYsIdWjSyixdupQxY8dSVlbGwBGX8a9f/JCoMIc7NlAjWfXSokVKVoVAW7tetLXzlaZRWFjIvHnzeGr202zauKF6fXK/FG69ZSLp6enEx8eHMEJpTLa8DA6WfmuNAZcLE6NSnS1Za7teVJ1P9pXDiQtv2L7cxZU+Or28skX9rK666ipGjBjBrbfeWmP9U089xVtvvcWSJUuOu00l5EVEpEl8N8lyuB5BzSHJ0tauF23tfKV+rLVQkg+Fe4NlaxK6YOISQx2WtELfTlbNv/kq2kVFcMrNv1Wyqhloa9eLtna+0rSstRQUFFBSUkJsbCwJCQkq19gG2LwdUJwPNhAcecihjg5d+mEiohrtczdt2kR6ejp5eXnEx8fzwgsvMHDgwEb7vLamtV0vqhPyV53dOAn5f33Qon5WMTExrF69mr59+9ZYv3nzZk499VRKS0sPc+ThqWSNiEgL0dJvolJTU9m+bVt1kmXBXa9Ub0vul8KsmTOVZBFpxowxEJeIjY6FwhyIiA51SNJKeTweJk+ezKRJk6h4ZxG2soK83FwSvF4lq0Sk1TDG4PV68Xq9oQ5FmlL7zsHyf6X7qJ633ALZX2HjO0BMAsblOqGPsNaSn59PaWkpMTExeL1ebrrpJn7xi18wfvx4XnrpJcaPH88nn3zSEGckrZgxpsHvvVrivZzX6+WVV15h6tSpNda/8sor9f4broS8iEgz1Fpvor6dZFGPIJGWyYRHQlKPUIchbYAxhrCwMMCS4NV1QkREWj7jCsMm9YCodsFygAEfhLmCSfp92bAvG+s4EN8BYhMwzrEn5wsLC5k7dy6zn55ToxxS7z4nsXvXThYuXAgEy2/ceuutbN68uVaPXxGp7f777+fGG29kxYoVDBs2DICPPvqI119/neeee65ebSohLyLSjLSVmyj1CBIRkeMSCIDLCXUUIiIiJ6x61GGkO1gOMD4JXOHBXvOFOfVKztcoD3pBGtfccHt1edCPX55P+ddf0eekk1i0cCGpqan06NGD7du3t8hnSWlCjgkuDd1mCzN+/HgGDBjAE088weLFiwEYMGAA77//fnWC/ngpIS8i0kzoJkpEROQ7nDCgMjiZsIiISCtiIt0Q6f5mRVxiMFEf8B8+Oe/pCDHtayTnly5dSlpaGn2Hj2D0PY8Sm9ixxuckdO3Fizu30qF3MmlpaWRkZDTVKYq0GsOGDePvf/97g7WnhLyISDOgmygREZE6VNXRtYHQxiEiItJEjOM6fHK+YA8U7KlOzhf5HcaMHUvf4SO4buY8XGG103zxnbqwf18eP134Hgvu/Dk/HjMGd3Q0PXqoBKEcjYEGLxnY8nrIb9++/Yjb6/O7pIS8iEiIFRYW6iZKRESkLlU9ANVDXkRE2qBayfmSAijaW52c9xUU8Pbcp9jSYTDbwxwq62gjJiGJLv0Hs/aNl7ly+iz+cOkQ2ns8Gmktcox69ep1xLmM/H7/cbephLyISIjNnTuXsrIyRt/zaJ3JeNBNlIiItE3GFYaFYOJBRESkDTOOK1hvPj7pUHI+n+wvv8ST4OX8BAvsxofhf5VxbPS1o5Jv5l658jczWXTfJJb/9TEi28ViHBfWWk2YLkdkjGnwfyMt8d/cqlWranxfWVnJqlWrmDVrFr///e/r1aYS8iIiIWStZfbTcxh4QVqtMjXfpZsoERFpcxyVrBEREfku47jIq3QY9MOruWHmXxl98QCGhhcThuWs8CLOCi/i9fJEdgWiAEjq1ZeJc/8DwJo3lrDgrgkUFBTg9XpDeRoiLcKQIUNqrTvjjDPo0qULf/zjHxk9evRxt6mEvIhICOXn57Np4wauueH2Wtu8FUWUhLmpcMIB3USJiEgbpJI1IiIidSotLQ1+4Y5jjS+WNb5YIggwIKyUvmFl+A5Tqzs6zgNASUmJniXlyBwTXBq6zVYiJSWFTz75pF7HKiEvIhJCVTdRVTdF35a2932sMczrcmmtiVR0EyUiIm2CJnUVERGpU0xMDAAHigur11Xg8Lkvjs99cYc9rmr/2NjYxgxPWgGVrAkqLi6u8b21lj179vDb3/6W5OTkerWphLyISAjVdRNVpSgshgRfMT0O5rA9ulONbbqJEhGRNqGqh7xqyIuIiNTg9XpJ7pfCumUZDLp41DEfl7Usg+R+KSQkJDRidCKth8fjqfUiwVpL9+7d+cc//lGvNpWQFxEJoSPdRL2edBY/3fMm5xd8VquXvG6iRESkTXAOPa6oZI2IiEgNxhhumXgzU6dNoyQv56hzkgEU52aTtTyTWTNntsieytLEVLIGgOXLl9f43nEckpKS6Nu3L2Fh9UutO0ffRUREGkvVTVTW2xmU5OXU2HbQFUleeDxh1k+vA3uq11fdRN16y0TdRImISOumkjUiIiKHlZ6ejtvtZvEDt+H3+Y64r9/nY8mDU3C73YwbN66JIhRp+YwxfP/73+e8887jvPPO49xzz6V///4AvPvuu/VqUwl5EZEQO9JN1BuJZxLA8IN9q8Fa3USJiEjb4ighLyIicjgej4dFCxeyeeVy5k8dR3Fudp37FedmM3/qODatXM5Lixbh8XiaNlBpmYxpnKWFGTFiBAUFBbXWFxUVMWLEiHq1qYS8iEiIHekmqtwVyd7IBMKsny7Z63QTJYc1e/ZsevXqRVRUFMOGDePjjz8OdUgiIifOpZI1IiIiR5KamkpGRga7Pv+Ihy8byoI7b2TNG0vY9OEK1ryxhAV33sjDlw1l1+cfkZmZyciRI0MdskiLYq2tszpBfn4+7dq1q1ebqiEvItIMVN1EjRk7locvG8rAEZcx8MI0ouM8PF66jzs8exlY/KVuoqRO//znP5kyZQrPPPMMw4YN47HHHiM1NZUNGzbQoUOHUIcnIlJ/1ZO6+kMbh4iISDOWmprK9m3bmDdvHk/NfpoFd71SvS25XwqzZs4kPT2d+Pj4EEYpLY1xDKaBa743dHuNafTo0UCwZM348eOJjIys3ub3+1mzZg1nn312vdpWQl5EpJk40k3URXf+gouGnszu/71HTPLgEEYpzdGsWbOYMGECP/vZzwB45plnyMzM5K9//St33XVXiKMTETkBSsiLiIgcE4/Hw+TJk5k0aRIFBQWUlJQQGxtLQkKC5h6T+mmMEjMt6N9i1Qssay2xsbFER0dXb4uIiOCss85iwoQJ9Wr7mBPyu3fvpkuXLvX6EBEROTaHu4lqHxuDfXcRbF+L7TtIN1TNSKivjxUVFXz66afcfffd1escx+Giiy5i5cqVIYtLRKQhGFcYFsCvhHxLE+rro4hIW2WMwev14vV6Qx2KSIv2/PPPA9CrVy+mTZtW7/I0dTnmGvIDBw7kxRdfbLAPFhGRw6u6ierVqxderxcnIhKT2BX8fuzOjaEOT74l1NfHvLw8/H4/HTt2rLG+Y8eOZGfXPalTeXk5xcXFNRYRkWbpUA95G/AdZUdpbkJ9fRQREZET5ACOaeAl1Cd1/O67774GTcbDcfwYfv/733PTTTcxZsyYOmeWbSqatE5E2ipzyjngONiN/8Nqcrtmo7lcH4/HjBkziI+Pr166d+8e6pBEROrmOlSyRj3kW5yWeH0UERERATjttNPYt28fAEOHDuW000477FIfx5yQnzhxImvWrCE/P5+TTz6ZV199tV4feCKqJq277777+OyzzxgyZAipqans3bu3yWMREWlqJiwc06FHsJf89vWhDkcOCfX1MTExEZfLRU5OTo31OTk5dOrUqc5j7r77boqKiqqXHTt2NEWoIiLHzxx6XFEN+RYn1NdHEREROTHGmEZZWoJRo0ZVT+J6xRVXMGrUqMMu9XFck7r27t2bt99+m6eeeorRo0czYMAAwsJqNvHZZ5/VK5BjoUnrRKStMycPx+7djt38GbZHCsa0wPFerVAor48RERGcfvrpLFu2jCuuuAKAQCDAsmXLuPXWW+s8JjIyssYM8SIizZajhHxLFurnRxEREZH6uO++++r8uqEcV0IeYNu2bSxevJj27dszatSoWjdUjaU+k9aVl5dTXl5e/b1q5IpIS2fCwjGdemN3f4Xd+gWm9ymhDkkOCdX1EWDKlCmkp6dzxhlncOaZZ/LYY4+xf//+6hfYIiItVtWLZ79qyLdUobw+QrDk6R//+Eeys7MZMmQITz75JGeeeWaTxiAiItIiVdV9b+g2W6iKigr27t1LIBCosb5Hjx7H3dZx3Q0999xzTJ06lYsuuoisrCySkpKO+wPr60iT1q1fX3fphhkzZnD//fc3RXgiIk3GDBiGzd6C/epzbK+T1Uu+GQjl9RHg6quvJjc3l3vvvZfs7GxOPfVUXn/99VrXTBGRFkcla1q0UF8fq0qePvPMMwwbNozHHnuM1NRUNmzYQIcOHZo0FhEREWmZNm7cyA033MAHH3xQY721FmMM/nrMdXTMCflLLrmEjz/+mKeeeopx48Yd9weFwt13382UKVOqvy8uLtbEdSLS4hlXGKZrX+yOjdiv12JOGhLqkNq05nJ9vPXWWw9bokZEpMWqqjOqSV1bnOZwfVTJUxERkRNgzDf3Yg3ZZgvzs5/9jLCwMDIyMujcuXOD1ME/5oS83+9nzZo1dOvW7YQ/tD7qM2mdauSKSGtl+p2B3bUZu2UdtvcgjKNe8qES6uujiEirVl1DXiVrWppQXx9V8lREROQEKSEPwOrVq/n000/p379/g7V5zBmcN998M6TJhm9PWlelatK64cOHhywuEZFQMK4wTPcUCPixX60OdThtWqivjyIirZp6yLdYob4+HqnkaXZ2dp3HzJgxg/j4+OpFo6tFRETk5JNPJi8vr0HbbFFdKqdMmcJzzz3H3Llz+fLLL7n55ps1aZ2ItFkm+TRwXNhtX2JVW1dERFoj1ZCXJnT33XdTVFRUvezYsSPUIYmIiISQ+aaXfEMttLwe8n/4wx+44447WLFiBfn5+RQXF9dY6qNpp7g/QZq0TkTkG8ZxYXoOCJat2bQKk3JGqEMSERFpWErISz2p5KmIiIg0hIsuugiACy+8sMb6JpnUtbnQpHUiIt8wJw0J9pDfsR6bPBTjuEIdkoiISMM5VLLG+lVDXo7Pt0ueXnHFFcA3JU/1PCkiInIMHOeb+Xwass0WZvny5Q3eZotLyIuIyDeM48L0PgX71efYDf/DDBgW6pBEREQajqMe8lJ/U6ZMIT09nTPOOIMzzzyTxx57TCVPRURE5Licd955Dd6mEvIiIi2c6T0oWLZm1yZsv9MxLv1pFxGRVkIla+QEqOSpiIjICaiu+97AbbYwa9asqXO9MYaoqCh69Ohx3CXvlLUREWnhjONgThqM3bQKu/5jzMCzQx2SiIhIw6h6aKtHbU4RUMlTERGRelNCHoBTTz0Vc4S4w8PDufrqq/nTn/5EVFTUMbXZ8gr3iIhILabXQHBc2D1fY32VoQ5HRESkYVT1kMeGNAwRERERaZtefvllkpOTefbZZ1m9ejWrV6/m2WefJSUlhRdffJG//OUvvP3220yfPv2Y21QPeRGRVsAYB5M8FLvhf9gvP8QMOjfUIYmIiJy4FtiLSkRERKRVUA95AH7/+9/z+OOPk5qaWr1u0KBBdOvWjXvuuYePP/6Ydu3aMXXqVB555JFjalM95EVEWgnTYwC4XNicbeolLyIirUL18GB1kBcRERGREFi7di09e/astb5nz56sXbsWCJa12bNnzzG3qYS8iEgrYYzB9DsdAgFs1n9DHY6IiEgDaXk9qURERERaPMdpnKWF6d+/Pw899BAVFRXV6yorK3nooYfo378/ALt27TquSeNVskZEpBUx3VKwGz/F5u7EVlZgwiNCHZKIiMiJMaAu8iIiIiISCrNnz+ZHP/oR3bp1Y/DgwUCw17zf7ycjIwOAr7/+mokTJx5zm0rIi4i0IsYYnP5nEshaiV37Hua0C0MdkoiIiIiIiIi0NKohD8DZZ5/Nli1b+Pvf/87GjRsBGDNmDNdccw2xsbEAXH/99cfVphLyIiKtTZe+sP4TbP4ebGU5Jjwy1BGJiIicAKMO8iIiIiISMrGxsfzyl79ssPaUkBdp4ez+YigpwJbswxbnQ8VBnDMvxbhcoQ5NQsQYgzPgLALr3sd+/g7mjJGhDklEROS4WWuhKK/qO2z+Hkjo9M1EryIiIiLSeNRDvoYvvviC7du316glD/CjH/3ouNtSQl6kBbPlZQRW/hsqysFaCPjA0wF8FeCKDnV4Ekqde8OXH2L37cVWHMRERIU6IhERkeNTkE3g8xXg9wEQ+HwFzqkjIKFTaOMSERERaQuUkAeC9eGvvPJK1q5dizEm2GkEqjuJ+P3+426z5U1tKyLf2JcT/K+/MjjhWWwCzmkXYiKVjG/rjDE4A88GGyCwenmowxERETl+Ue7gf8PCICw8+HV0TOjiEREREZE251e/+hW9e/dm7969uN1usrKyePfddznjjDNYsWJFvdpUD3mRFsiWFhH4+D/BHmPGQFgEREThDL0A0y4+1OFJc9GxJ7jCoCgPW35AL2pERKRFMe3iIc4LhTmAgfhEjBLyIiIiIk3DcYJLQ7fZwqxcuZK3336bxMREHMfBcRzOOeccZsyYweTJk1m1atVxt9nyfgoibZitKMf/wasEPswIlqeJjMY590rMwLODyfj4xFCHKM2IMQZn0DlgLYHPloU6HBERkeNmOvUKfmEtJqlbSGMRERERkbbH7/cTGxsLQGJiIrt37wagZ8+ebNiwoV5tqoe8SAtgA37s+k+wu78GGwBXGM4ZF2PivACYHv1DHKE0W0ndg73kS/dhC3MhxoOpGvYvIiLSzJnEbljXZ2ADGG+XUIcjIiIi0naohjwAp5xyCp9//jm9e/dm2LBhPPzww0RERPDss8/Sp0+ferWphLxIM2atxe7ahN3wKQT84LhwBn4fOvWqnjxC5EiMMTj9zySQ9QGBj14Ddyyuc0eHOiyRRmH9fsjeCrHtISYe47hCHZKInCAT5Q5O4lpWDDHtQx2OiIiIiLQx06dPZ//+/QD87ne/Iy0tjXPPPRev18s///nPerWphLxIM2X37SWw6u1gnXjHwfQcgEkeijGqNCXHJ7BrE5SXBd9El1lsZQUmPCLUYYk0OLvna+yqFWAthIdDXCLGk4RJ7ILp2CPU4YlIPTmDz1NHBBEREZGmZmiEHvIN21xTSE1Nrf66b9++rF+/noKCAtq3b1/ve1Ql5EWaGXugNFgj3ndowlZPEs7QEZgwJVClfkzHntiCPcGXO4EAHCiBcG+owxJpcKZTL6y3M+zZEizvlbsTm7MNuz0GZ+R1GJdue0RaIiXjRUREREJAJWsOKyEh4YSO15OpSDNhfZXYz9/B7ssJ9u50heEMT8NEx4Q6NGnhnJ4nE8Bgv1wJfn9w2H+cEvLS+piwcJwzLiKwMhMKciDKDfuLwXHAVxmcT0FERERERETkKH7+858f035//etfj7ttPZmKhJi1AexXn2O3fRnsvexy4Zw6ApPQKdShSSvi9BxAwBjs+o+Doy9EWikTEYVzZiqBDzKgcG8wKe+rJLDsH5juyZiTh2Ncqi0v0pzZQACMUc94ERERkRAyjoNxGrZsckO315heeOEFevbsydChQ7HWNmjbSsiLhJDN2UYg64Ngr2XHwaScgemeogdQaRROj/7YpG4adSGtnomOCSblP12G6d4PExlNYO0H2G0bsDs34wwcDt376W+tSDNkrcVuWxcczXXy9/V7KiIiIiIhcfPNN7NgwQK2bNnCz372M6677roTLlVTpeW8lhBpRWzJPvxv/4PAmvcgEMB07o0z4mqcHv314CmNSsl4aStMbHtc5/8Y56TBmG7JwRryvQeCtQTWvE9g6d+w+/aGOkwR+a78XcGlvAxo2J5IIiIiInI8zDd15BtqaUGzus6ePZs9e/Zwxx138Oqrr9K9e3fGjh3L0qVLT7jHvBLyIk3IVhzE//7LBD7KhIAP3DE4P7gK55TvYxyVUBARaSzG5cIZeBbORT+FeC/4fQQ+eBX/WwuwB/eHOjwRAeyBEuyO9cFJyEH5eBEREREJqcjISH7605/y5ptv8sUXXzBw4EAmTpxIr169KC0trXe7KlkjcoJGjhxJdnY2juMQGxvLE088wdChQ2vsYwN+7BcfYrO3fjNh6/dSMbHtQxO0iEgbZSKicJ17BbZkH4EPXoXyMgJvL8R07oUZdA4mLDzUIYq0Sdbvw25ZC5UVEBZZtTakMYmIiIi0adW92hu4zRbKcRyMMVhr8fv9J9SWEvIix8FaS35+PqWlpcTExOD1elm4cCEejweAl19+mfHjx/P5559X72+3r8duXvXNhK0Dv4/p2COEZyEiIia2Pa7UcdjsrQRWv4Pd9TU2exsm5XRM71NUPkykidncHVC6DxwXwUS8CXZiEBEREREJkfLychYvXsxf//pX3n//fdLS0njqqae45JJLcE5gglol5EWOQWFhIXPnzmX203PYtHFD9frkfincMvFm0tPT8Xg8FBUVVSdxbP4eAp+v+GbC1j6DMH0GK8kjItKMmE69cEb2wG5ejf1qDfaLj7EbP8M54yJMYtdQhyfSZpg4Lza2PewvCt47abSKiIiISGi18R7yEydO5B//+Afdu3fn5z//OQsWLCAxMbFB2lZCXuQoli5dypixYykrK2PgBWlcc8PtRMd5OFBcyLplGUydNo1pt9+OJz6eqKgoMv+1CP/b/wjWPzUG4+2MGfwDlUEQEWmmjONg+p2G7T2QwKdvQ8EeAh+9DmHhOOdcgWkXF+oQRVo9447DOmHghGG69IYo96He8iIiIiISEo4TXBq6zRbimWeeoUePHvTp04d33nmHd955p879Fi9efNxtKyEvcgRLly4lLS2NvsNHMPqeR4lN7Fhj+6CLR1GSl8PiB24je9UHTL12FHfe+ksy/t80CAvDGX45JqpdiKIXEZHjYcIjcZ11KXZ/MYH3l4CvksA7L4G3C85pF2DCI0IdokirZa2FAyXBh7TOJ2lEoYiIiIiE1Lhx4xrtnlQJeZHDKCwsZMzYsfQdPoLrZs7DFVb3r0ucN4mn7vs1Xb76L7byIHfP+YJ9fc4gsU//Jo5YREQagmkXF6wvn7uLwKdvQe4uAm+9iDlpMKbvqZgW1KtDpMUoKw7OtxPbXsl4ERERkeagjZeseeGFFxqtbT1RihzG3LlzKSsrY/Q9j9adjLeWTjlfMnLtPxh0YBuxHTvzi9kLiIx24+2d0vQBi4hIgzJJXXFSx2EGnAmA3biKwBt/w2ZvC3FkIq2P3bMZANO5b4gjERERERFpXOohL1IHay2zn57DwAvSapWpAUisKOSHeR+yJyeHnz80myIfHAyLpiS/iIR4T9MHLCIijcIYgzlpELZnf+zn72Jztgd7zYeF45z9I0ysJ9QhirR41looLQz2mGoXH+pwRERERATafA/5xqQe8iJ1yM/PZ9PGDZxyYVqtbWcWfsHluf/FZf2069Kb6xe8zy/+9TGT//kOl98xg+3bt1FQUBCCqEVEpLGYsHCc0y/EGTEGIqKC9eXfXYz/v//GVhwMdXgiLdvB0mC5mqh2KlcjIiIiItXeffddLr/8crp06YIxhiVLltTYbq3l3nvvpXPnzkRHR3PRRRexadOmGvsUFBRw7bXXEhcXh8fj4YYbbqC0tLQJz6I2JeRF6lD1ixkd56ljq6XShLG4w3ks6fgDKpxvJvmr2r+kpKTxgxQRkSZnomNwXXwtzvA0cIVBYS6BtxYQ+OIjbMAf6vBEWiSbvQUA07VfiCMRERERkWpVPeQbejkO+/fvZ8iQIcyePbvO7Q8//DBPPPEEzzzzDB999BHt2rUjNTWVgwe/6TR17bXXkpWVxZtvvklGRgbvvvsuv/jFL07oR3OiVLJGpA4xMTEAHCgurLXtY89APvYMrPO4qv1jY2MbKzQREWkGTEJHnNTrsTs2YLM+xH69DrttPc7g70OXk9TLV+R4FOUGH85iE0IdiYiIiIg0I5deeimXXnppndustTz22GNMnz6dUaNGATBv3jw6duzIkiVL+MlPfsKXX37J66+/zieffMIZZ5wBwJNPPskPf/hDHnnkEbp06dJk5/Jt6iEvUgev10tyvxTWLcs4ruOylmWQ3C+FhAQ9ULYVtrIcW1Yc6jBEJASMMTg9+uOMvA7TIwVsgMDqd4ITvxblhTo8kRbBHiwLlqsJj9SLLBEREZHmxHEaZ2kgW7ZsITs7m4suuqh6XXx8PMOGDWPlypUArFy5Eo/HU52MB7joootwHIePPvromD/rb3/7G9///vfp0qUL27ZtA+Cxxx7jlVdeqVfsSsiL1MEYwy0Tbybr7QxK8nKO6Zji3Gyylmdy6y0T9UDZlpTug8IcbHlZqCMRkRAxrjCcwefgXHh1cEJKn4/A+//Gv2KR/jaIHIXduxUA071/aAMRETkBI0eOZPDgwZx66qmce+65rFq1KtQhiTQoay324H7sgdDW3ZYm1ogla4qLi2ss5eXlxx1ednY2AB07dqyxvmPHjtXbsrOz6dChQ43tYWFhJCQkVO9zNHPmzGHKlCn88Ic/pLCwEL8/WKrU4/Hw2GOPHXfcoIS8yGGlp6fjdrtZ/MBt+H2+I+7r9/lY8uAU3G4348aNa6IIpVnw+yDgg6JcrA2EOhoRCSET6cZ1/o9xzvkRhIXB/mICy/5J4PP3sP4jX0dE2qyC7EPlaryhjkRE5JhYa8nLy2Pr1q3k5eVhrWXhwoWsWbOG1atXM2XKFMaPHx/qMEVOmPX7sIV7CWz/gsDadwisWU5g86dYa0MdmrQC3bt3Jz4+vnqZMWNGqEM6rCeffJLnnnuO3/zmN7hcrur1Z5xxBmvXrq1Xm0rIixyGx+Nh0cKFbF65nPlTx1GcW/ebs+LcbOZPHcemlct5adEiPB5P0wYqoRXwgXGgsjzYW15E2jwTn4gz8nqcU88H42B3bCTwxnwC27484QcY9cCT1sRWHICAHxwXpgGHL4uINIbCwkIef/xxUvoPICkpid69e5OUlERK/wHMnTuXwsJCAIqKijRiWlqFwJY1BNZ/iN21CUoLIBDAdOipf99tSSP2kN+xYwdFRUXVy913333c4XXq1AmAnJyalS1ycnKqt3Xq1Im9e/fW2O7z+SgoKKje52i2bNnC0KFDa62PjIxk//79xx03aFJXkSNKTU0lIyODMWPH8vBlQxk44jIGXphGdJyHA8WFZC3LIGt5Jm63m8zMTEaOHBnqkKUJWWvB7wdrAQtlxdiYBN2giEjw70DXk3A698Ju+BS7JQu79gPsl5/gnDkSk3D0mz9rLfn5+ZSWlhITE4PX62XhwoXVL35ffvllxo8fz+eff97IZyPSSPZuB1SuRkSav6VLlzJm7FjKysoYeEEa19xwe/Uz4bplGUydNo1pt9+OJz6eqKgoXnvttVCHLHLiAn6wAQiLAJ+FxG6YDj1DHZW0EnFxccTFxZ1QG71796ZTp04sW7aMU089FQiWwvnoo4+4+eabARg+fDiFhYV8+umnnH766QC8/fbbBAIBhg0bdsyfs3r1anr2rPnv//XXX2fAgAH1il0JeZGjSE1NZfu2bcybN4+nZj/Ngru+mbAhuV8Ks2bOJD09nfj4+BBGKSETEQWVBJPy8UlKxotIDcZxYQaciT1pMIFP3oTCXAIrMyE8EufcKzDRMbWOKSwsZO7cucx+eg6bNm6oXp/cL4VbJt5Meno6Ho9HPfCkxbP5u4K9pOI7HH1nEZEQWbp0KWlpafQdPoLR9zxKbGLNWsWDLh5FSV4Oix+4jc0rl/OrX/2KO++8U0l5abGs30dg3XtQcSCYjK84CLEJOL0G6d6zrWngSVir2zwOpaWlbN68ufr7LVu2sHr1ahISEujRowf/93//x4MPPkhycjK9e/fmnnvuoUuXLlxxxRUADBgwgEsuuYQJEybwzDPPUFlZya233spPfvITunTpckwxTJkyhVtuuYWDBw9ireXjjz9mwYIFzJgxgz//+c/HdT5VjG1DxZ+Ki4uJj4+nqKjohN/CSNtkraWgoICSkhJiY2NJSFBv6LbOWgvFeVBWBAldMZHRoQ5JGkBbu160tfMNJVtaSOC//wZfZTAR2aEHzqnnYcLCgdo98E751qisdcsyyHo7A2NMjR54gwYNCvFZiRw/W1mOXfsuuFw4Qy4IdThyjNra9aKtna/UVlhYSI+ePek6ZBjXzZyHK+zwfRr9Ph/zp45j1+cfUVlRwc6dO/F6NT+GtCx2Xw6Br1dBIACuMJyThhLI24XTuQ/Grb+Dh9ParhdV51Pw+5uIi4po2LYPVpDwmz8d889qxYoVjBgxotb69PR0XnjhBay13HfffTz77LMUFhZyzjnn8PTTT9OvX7/qfQsKCrj11lt59dVXcRyHq666iieeeIKYmNqdow7n73//O7/97W/56quvAOjSpQv3338/N9xwwzG38W1KyIuInCBbWQ55OyAqBtP+2GqQSfPW1q4Xbe18mwObs53AquXg84HLhel3Gm9u2k3a5ZcftgceUKsH3hdffKEeeNIi2T1fYfd8jekxAJPYLdThyDFqa9eLtna+Utvjjz/O1GnTuPO11XVelwEOlBRRefAAcUmdKM7N5g+XDiE2NpZ9+/ap85a0GDbgJ/Dlh8GOZsZguvbDdOqjf8PHqLVdL6oT8v/vJuKiIhu27YPlJPz62BPyzU1ZWRmlpaV06HBiIzxVskZE5ESFHXpjXF4W2jhEpMUwHXvgjLwe+9Xn2M2f48v6kA4bNjLmyisZePsTh+2BF5vYketmzmP+1HE8+9xzVFZUkJ+frx540uLYvdvAAHqRLSLNlLWW2U/PYeAFaYdNxgMcLCnmxTtvoLL8IMY4uD0JxMe0a8JIQ8vu3YXdsw3TZwAmtn2ow5F6sMX5BDZ9EuwV77hwTvmBRn5L0LcmYW3QNluYLVu24PP5SE5Oxu1243a7Adi0aRPh4eH06tXruNtUQl5E5AQZY7DGAWux1qoXgYgcE+M4mOSh2F4Dyfrbk4Q7hkd/fD6+na/xStcLKA6vOYTy2z3wrpw+q7oHXkJCQojOQKR+rK8yOFGc48K49DgiIs1Tfn4+mzZu4Jobbq+1zV1ewsVrXybmYDHWGCbefCUBHKwxlBTksWtjFuXz/kh4ZNShhJYDjsEYp/prjBPc5jhH/9ocquNsTuw4U/25R4vhW/tVPdsYJ/giFVMjSRd44x+Qsx0bGQ1d+2D6Dsb0ORnTruX1fG1rbMBPYPOnUJQX7BXfqQ+mW4qeZ0W+Y/z48fz85z8nOTm5xvqPPvqIP//5z6xYseK429QdsIhIQ4iMhoP7wVcB4Q07pEtEWrmwcH78h+foefIQXhh3MuGBSn68802yI7281fEsKlzBUThtvQeetCIFu8GC6dQn1JGIiBxWaWkpANFxnlrbEktySCjNrfO4CMeHKz4GCvMhIrzGtlDXC26Uz/f7DzVuYeNq7JYvsd2TcY2Z2BifJg3E7i8ksP6j6hfkzsBzMFG6r5TvUA95AFatWsX3v//9WuvPOussbr311nq12WIS8r///e/JzMxk9erVREREUFhYGOqQRES+4Y4PJuTLiiE+KdTRiEgLUtUD73s33M7fel1O5wN7uTjnQzofzOOa7a/xZsfh7HJ3pH2X7tzytzeqj1vzxhIW3DWBgoIClayRFsXu+SrYy9LbJdShiIgcVtVkfweKC2tt257Ylxd+8H8YLMYC2Oqv1y17lX899wxbvv46OIrNBg5lwm0waV01jd9h11d9XbX+u/vUsf7b2wOBQ18Hjvq1/e56G/hWG4f7+jttrP8MyvxQWQkxHuiRjNP/9Eb7/0VOjLUB7Ja12ILdAJjE7phep6hXvMgRGGMoKSmptb6oqAh/1UvJ49RiEvIVFRWMGTOG4cOH85e//CXU4YiI1BQRFfzvgZIaCfnJkyfz73//m23btrFq1SpOPfXU0MQnIs3Wd3vg7YnuwLyelzOw+CvOKMjCU1nCLmrXrq3av6SkRAl5aTGs3/dNuZqqOVhERJohr9dLcr8U1i3LYNDFo2ptt46rzh7nn739Hzr17ENC567NPsnZENEF2idid36N02cg9ErBRMcc/SAJCXuglMAX//2mV/yA4Ri3SgvJEVSVvWroNluYH/zgB8yYMYMFCxbgcrkA8Pv9zJgxg3POOadebbaYhPz9998PwAsvvBDaQERE6mBMsGYk1pKXm0vp/v3ExMRw1VVXcccdd9T7j7SItH519sAzhqz4vmTF9z3scVX7x8bGNmJ0Ig1sX3awXE2HnqGORETkiIwx3DLxZqZOm0ZJXs4RJ3atUpybTdbyTGbNnNnsk/ENxRlyDgzRs05zZq3F7vgyOKG6teDpiHPSUExDJ1pFWqmHHnqI8847j5SUFM4991wA3nvvPYqLi3n77bfr1War/u0rLy+nuLi4xiIi0hgKCwvZtGUbm7/azJBBp9C7d2+SkpKY8Iub+Ne//kUgEAh1iCLSTH27B97xyFqWQXK/FE3qKi2K3bUx+EVit9AGIiJyDNLT03G73Sx+4Db8Pt8R9/X7fCx5cAput5tx48Y1UYQiR2bLywh89gY2ZysYB6f/WbiST1cyXo6NMY2ztDADBw5kzZo1jB07lr1791JSUsK4ceNYv349p5xySr3abNW/gTNmzCA+Pr566d69e6hDEpFWaOnSpfTo2ZMp9z6ACY/k/tl/5oY5L3HNH/5MdK8BTJ02jZ07d/LBBx+EOlQRaYaqeuBlvZ1BSV7OMR1T1QPv1lsmtpkeeNLy2YA/WHPY5cJoAnQRaQE8Hg+LFi5k88rlzJ86juLc7Dr3K87NZv7UcWxauZyXFi3C4/E0baAi32GtJbBrE4G17wRL1MS0xxl6ESZWHTlEjkdlZSUXXngh+/fv5//9v/9HZmYmL730Evfee+8JdYwKaUL+rrvuwhhzxGX9+vX1bv/uu++mqKioetmxY0cDRi8iEkzGp6Wl0XXIMM686yniO3TmkqEp9B12HoMuHsVPH3qOO19bjSsiksmTJ7N06dJQhywizZB64EmbUJgL1mK8XUMdiYjIMUtNTSUjI4Ndn3/Ew5cNZcGdN7LmjSVs+nBFcIL1O2/k4cuGsuvzj8jMzGTkyJGhDlnaOFtxkMCqN7G7N4ExOP2+h2vAcIzjCnVo0tKohzzh4eGsWbOmwdsNaQ35qVOnMn78+CPu06dPn3q3HxkZSWSket+ISOMoLCxkzNix9B0+gutmzsMVFoafAsJNzemdYhM7EpOQiKdTN8aMHcv2bdvUa0ZEaqjqgZeWlsb8qeO4cvos4pI61dqvODeblx+cwuaVy8nMzNTfEmlR7M5DHW069AhtICIixyk1NZXt27Yxb948npr9NAvueqV6W3K/FGbNnEl6ejrx8fEhjFLaismTJ/Pvf/+bbdu2sWrVKk499VTgUK34vVuxOzaADUBUO5yTv49xtZjpI6W5MU7DT8LaAid1ve666/jLX/7CQw891GBthvS3MikpiaSkpFCGICJSb3PnzqWsrIzR9zyKKyz45/RgwNDOsUSZAAftty80hgsmTGXu5J8yb948Jk+eHJqgRaTZquqBN2bsWB6+bCgDR1zGwAvTiI7zcKC4kKxlGWQtz8TtdqsHnrQ4NhAAvw8cFyYiOtThiIgcN4/Hw+TJk5k0aRIFBQWUlJQQGxtLQkKCysdJo7HWkp+fT2lpKTExMXi9Xn784x9zxx13cM4530ymaysrCKxdEbzWGic4aWtC55DFLdKa+Hw+/vrXv/LWW29x+umn065duxrbZ82addxttpjXZNu3b6egoIDt27fj9/tZvXo1AH379iUmJia0wYlIm2OtZfbTcxh4QRqxiR2r168tj+Ks6DJ6hFewsSKKlx+cyvr336Q0fy8Lp0/EFR7JU7OfZtKkSbpxF5Fa1ANPWq2SfH71h6d49f1P2LZrd40efSIiLYkxBq/Xi9frDXUo0ooVFhYyd+5cZj89h00bN1SvT+6Xwi0Tb2bw4MHV62zeLgJb1wZ7xYeF4ww6HxMWHoqwpbVxTHBp6DZbmHXr1nHaaacBsHHjxhrb6pvXaTEJ+XvvvZe5c+dWfz906FAAli9fzvnnnx+iqORwysvLmTp1KkuXLiUqKoohQ4Ywf/78UIcl0mDy8/PZtHED19xwe431WyoiDyXkK9lYEcWV02fW2L7mjSUsuGsCBQUFuokXkTqpB560Ft/u1dd53xauuuhc7njwYc69SKM7pPH9/ve/JzMzk9WrVxMREUFhYWGoQxIROSZLly5lzNixlJWVMfCCNK654fbqEZPrlmUwddo07rn3XtxRUfg3fEygshsYB9PrFJwklYUTaWjLly9v8DZbTEL+hRde4IUXXgh1GFKHuoZQVU3Yu3HjRowxZGfXPRu9SEtVWloKQHScp8b6Muvwflk7cnx1/3mt2r+kpEQJeWkQSji0XuqBJy3Vd3v1OY7DqrmzSIqJYnHmfwgEAqEOUdqAiooKxowZw/Dhw/nLX/4S6nBERI7J0qVLSUtLo+/wEYy+59Eao7EBBl08ipK8HHb9/WHeyHiVAyVF4OqFM+g8TLjmUJQGphrytezcuROAbt26nVA7LfunICFVWFjI448/Tkr/ASQlJdG7d2+SkpJI7pfCnDlzuP3226t78nXqVHtiOpGWrKpU1oHiwlrbNlREURioOyFftX9sbGxjhSZtTFXC4eabbw51KCIiLF26lB49ezJ12jSiew3gmj/8mQeeX0hCp658nl3M1GnT2LlzJx988EGoQ5VW7v777+e2225j0KBBoQ5FROSYFBYWMmbsWPoOH8F1M+fVSsYDhFk/17lz+MMNV2EcwxP/eIWS3t9TMl6kEQUCAX73u98RHx9Pz5496dmzJx6PhwceeKDeHU1aTA95aV6ONITqkyV/p3zzJpKTk+nZsycdO3bkt7/9LRdeeGGowxZpMF6vl+R+KaxblsGgi0cd83FZyzJI7pdCQkJCI0Ynbcn9998PoFFkIhJyh+vVd0X5F0TaMkrPvZY7X/sRD19+BpMnT+akk04iNTU1xFGLiIg0D3PnzqWsrIzR9zyKK6x2uq6zv4iRB9fjsgF8xkWZE8m/VnzIOX/7G5MnTw5BxNLqGRNcGrrNFuY3v/kNf/nLX3jooYf4/ve/D8D777/Pb3/7Ww4ePMjvf//7425TCXk5bkcbQpXQrRebVi7H2yuZLV9v4Fe/+hVXX301WVlZdOxY+w2vSEtkjOGWiTczddo0SvJy6uy98F3FudlkLc9k1syZqgMtIiKtynd79VUnEqylvT2AH0OBiSY20U1MQiKeTt0YM3Ys27dtw+PxhDR2kSrl5eWUl5dXf19cXBzCaESkLbHWMvvpOQy8IK3Ws6VjA4w8uJ4ugSIshp/PeoH3PlhJaf5eHFcY06ZNY9KkSXrGlIbnOMGlodtsYebOncuf//xnfvSjH1WvGzx4MF27dmXixIn1Ssi3vJ+ChNSxDKHydOqGcRxunruUvsNHcPevf02PHj1Yu3ZtCCIWaTzp6em43W4WP3Abfp/viPv6fT6WPDgFt9vNuHHjmihCkbqVl5dTXFxcYxERORGH69XXwe7HwZLjxHyrR5ThgglTKSsrY968eaEJWFqkqnmqjrSsX7++3u3PmDGD+Pj46qV79+4NGL2IyOHl5+ezaeMGTrkwrda2DoFSOgeK8eHwr+ghnHPvn7j79TX8/pNsxvzuKSorKykoKAhB1CJtQ0FBAf3796+1vn///vX+3VNCXo7L0YZQAbRr7+WkM3/AV5+8y5XTZ7F//342btzIgAEDmjhakcbl8XhYtHAhm1cuZ/7UcRTn1j15cXFuNvOnjmPTyuW8tGiRegLKUSnhICItyZF69Z3h2wXA/8K68fKDU5lxyWCK9+5m4fSJuMIjeWr201hrQxG2tEBTp07lyy+/POLSp0+ferd/9913U1RUVL3s2LGjAaMXETm80tJSAKLjPLW27XVi+HfUKcxzn0mxE11jW9X+JSUljR2itEVVJWsaemlhhgwZwlNPPVVr/VNPPcWQIUPq1aZK1sgxq+thy+WvxF1eihPwUxSTWL3vlb/+I//63f+xv7CAiOh2xMbG0KVLl1CFLtJoUlNTycjIYMzYsTx82VAGjriMgRemVc+pkLUsg6zlmbjdbjIzMxk5cmSoQ5YWYOrUqYwfP/6I+5xowmHKlCnV3xcXFyspLyL1VtWr75obbq+1rUOglACGXOPmyukza2xb88YSFtw1gYKCArxeb1OFKy1YUlISSUlJjdZ+ZGQkkZGaGFFEml5MTAwAB4oLa20LGId8V0ydx1XtHxsb21ihibR5Dz/8MJdddhlvvfUWw4cPB2DlypXs2LGD1157rV5tKiEvh2UrDkJpEXZfHuTs4MDWTfzlzO506plEu6UzcOw3Mwlb4/Dvs29gX2wHIFhHfsKzSwA9bEnrl5qayvZt25g3bx5PzX6aBXe9Ur0tuV8Ks2bOJD09nfj4+BBGKS2JEg4i0pIcqVffRlci+Y67zt5Q3+7Vp3tEaWjbt2+noKCA7du34/f7Wb16NQB9+/atTnyJiDQXXq+X5H4prFuWwaCLRx3zcVnLMkjul0JCQkIjRidtlnGCS0O32cKcd955bNy4kdmzZ1ePVB89ejQTJ06sd+djJeTbIGstHCwLJtvzcyBnBzZnJ3bvTrAWAn4IBGod51RWEh8VTuSh3x2fKxy/E0ZefBd2Jp3Evpi6k0d62JK2wOPxMHnyZCZNmkRBQQElJSXExsaSkJCgyXWkUSnhICKhdqRefR+E9zzscerVJ43p3nvvZe7cudXfDx06FIDly5dz/vnnhygqEZG6GWO4ZeLNTJ02jZK8nDrn6/uu4txsspZnMmvmTD1zijSCr7/+mt69e2OMoUuXLvWavPVwlJBvZWwgAGWlwWR73h7I3o7N2YHdlxtMtvv9YGsn279hwOWCsDBMdDvo1B3TqTumQzeK/PC95P78+P89e1xvbPWwJW2JMQav16uXT9JklHAQkVBTrz5pjl544QVeeOGFUIchInLM0tPTuefee1n8wG1cN3PeYeftA/D7fCx5cAput5tx48Y1YZTSphgavuZ7C3p3lJyczJ49e+jQIVgN5Oqrr+aJJ56gY8ejvzA7GiXkWxDr98H+EigpxO7dic3ZCdk7sKWFwR7tAX8w6X44xoDjAicME9ceOnbHdOyO6dAVYj3gjsW4XIc9PMFaep6UrIctEZFmRAmH5sdaq15K0qaoV5+IiMiJ83g8LFq4kLS0NOZPHceV02cRl9Sp1n7Fudm8/OAUNq9cTmZmJh6Pp+mDFWkD7HdyrK+99hozZsxokLaVkG8mbGUF7C+GooJgj/acncHe7QcPgPWDPwAcKdnugCsMjMEkdMR06h5MuCd2hph4iG6HcU6sTpMetkRERI7MHiglsHQ+YKB9EiYuARPbHmLbQ2LXI774FmnJ1KtPpG0qLy9n6tSpLF26lKioKIYMGcL8+fNDHZZIi5WamkpGRgZjxo7l4cuGMnDEZQy8MI3oOA8HigvJWpZB1vJM3G43mZmZjBw5MtQhS2vmOMGlodsUJeRPlK0ox36dhenVHxPlrr3dWqgoh/1FwbIx2TuDCffsHeD3HarX7j/yhzguCAsHA6ZTD0zHbsFke/sOEBsPkdFNluzWw5aIiEjdrK8ScndBUT74KiF/D9aY4L1ARBQm9TpMh26hDlOkUahXn0jrZ60lPz+f0tJSYmJi8Hq93HXXXRhj2LhxI8YYsrOzQx2mSIuXmprK9m3bmDdvHk/NfpoFd71SvS25XwqzZs4kPT2d+Pj4EEYpbYIxjVCypuV01jXG1Mq3NlT+VQn5erL7S7BrVhL47B0oKsD0HoDp0gubvR2bu/uIk6PW4LggLAIiIjEduwVLyHTqDp5EaBeHiYhsmhM6RnrYEhGRts4GAlBaCPnZ2B0bsXu2BK/5/kMv2C2HXqQ7UFkefHE+4HuYeM0tIa2bevWJtE6FhYXMnTuX2U/PYdPGDdXrT+qbzM4d26uT8QCdOtV+NhSR4+fxeJg8eTKTJk2ioKCAkpISYmNjSUhIUPUBkSZirWX8+PFERgZzswcPHuSXv/wl7dq1q7Hf4sWLj7ttJeTrIbBhNYHX/g6lReBy4OBB7J5t2Ozt39rrW5OjumOCPdo7dQ/2bo9LCCbbj9C7vDnTw5aIiLQF1lo4UAr79mJ3fYXdvgF8FYcmSP9OGTmXC8IjMJ17Y3N3Qf4eiHLDgO/hDPo+JtYTknMQaWrq1SfSuixdupQxY8dSVlbGwAvSuOaG26uf+z5Z8nfKN28iOTmZnj170rFjR377299y4YUXhjpskVbDGIPX68XrVccOCQHjBJeGbrOFSE9Pr/H9dddd12Btt8yMcKiFR4A7JvhQXlkJYWHguHBdfUuwXvtRJkdtDfSw1bYdPHiQn/zkJ3zxxRdER0fToUMH5syZQ9++fUMdmohIvdiKg1CUj92zFbt9ffClu98P9jsj3RwHwsKDZeN6pARL0MR5MWHh1bsEtq3HbtuAc8owTIJ6Ckrbo159Iq3D0qVLSUtLo+/wEYy+59Fac4gldOvFppXL8fZKZsvXG/jVr37F1VdfTVZWFh07Hn2+MRERkebs+eefb7S2lZCvB6fPyTg33YctLQrWgs/ejunaG9O5Z6hDa1J62Go7vlsvsl27dvziF7/g0ksvxRjDU089xY033siKFStCHaqINCPNcaI36/dBcUGwF/v2Ddj8PcHE+3fnczEmOFm624PpkYLp3Bs8iZjI6KN+htOzP/Ts30hnINJyqFefSMtVWFjImLFj6Tt8xGHnDvN06oZxHG6eu5QX7/gZd//61/Q96STWrl2rhLyISGtgDDhtt4Z8Y1JC/gSYmHhM33joe0qoQwkpPWy1XoerF5ncL4VbJt7M2Wefjcfj4ayzzuKRRx4JYaQiEmrNbaI3awPBXu4FOcE677u+Cs7r4vfV3NGY4HwuEZHBxHu3vtC+Y3C0m24WRUSkjZo7dy5lZWWMvufROpPxAO3aeznpzB/w1SfvcuX0Wfzhh6eyceNGBgwY0MTRioiItCxKyItInY5UL3LdsgymTpvGPffey6KFC5k/fz6jRo0KdcgiEgKhnujNWgsHy6Aw91Cd9/VQUR5MvB+uznvHHpju/SCxC8R6ME7rLjMnIiJyPKy1zH56DgMvSKtVpua7rvz1H/nX7/6P/YUFRES3IzY2hi5dujRRpCIi0qjaeA35xqSEvIjUcrR6kYMuHkVJXg6LH7iNH/7wh/Tr149PP/00RNGKSKg09URvtrI8WOc9e1twgtXifYcS74ep8x7vhR79MR27B+u8h0ec4BmLiIi0fvn5+WzauIFrbri9xvoIfwVJ5QXsju6APZRQSejWiwnPLgFgzRtLWHDXBAoKCjR6WkSkNTCm4UvMaBQyoIS8iHzHsdSLBIhN7EivocPZuupDdu7aRUVFBW63u4mjFZFQacyJ3qzfDyUFkLcbu30jNnfnkeu8R8UGy8106QOeJEyU/haJiIjUV2lpKQDRcR6MDdCzbA/n7v0fYdaHxbC08znsie5Q67joOA8AJSUlSsiLiIgcgRLyIlLDsdSLBHhv/hzWvLGEX77wH578yfnMmzePyZMnN2GkIhIqDTXRm7UB2F8SrPO+cyN2x+Zg0j3gr1lupqrOe3gkpnsypntysM57u1iMhjyKiIg0qJiYGHp3SOD6sB2kbHkFhwAW8Jkw/pdwCnuikuo87kBxIQCxsbFNF6yIiDQelaxpNErIi0i1o9WLDPNX4nOFU5Szm9dm3UtCt17889c3ER7l5o4772TSpEmaBFGkDajPRG/PXHUmmzduIMVXgP/lOVB+oO46744rWG4mqRumRz9I7Aqx7TEu1XkXERFpTLayHPv1Wtp/vY7Xf3MTTmUh1rTjq3Y9+CThFMrCoo94fNayDJL7pZCQkNBEEYuIiLRMSsiLSLXD1YsESCrN4bIvX6YkIo6XB13NjM9yq7epXqRI23EsL+48BwvpXLqbJ68eye+ens5HJfvpGOPmlvNOo0veluCOjgOucIhrHyw306knxHsx4ZFNfEYiIiJtl7UWcrYTWL3imxflxhAZ354xv5/NxU9lEJt09EnZi3OzyVqeyayZM9VBR0SktXBMcGnoNkUJeRH5xrfrRX7XvugE/MZF/MFCrvvsL7x8ytWURMXX2F/1IkVavyO9uDtn6zv0K9jwzYpYeHnajfiNi30lJcx/7Q1KzriE+J59IcqtB3YREZEQsaWF2HUfYAuyIRAAA7jCMCnfw/RIIb6klPWTH6TkwSlHnFcKwO/zseTBKbjdbsaNG9d0JyEiItJCKSEvItViYmKAb+o/fpvPFc7fTr+Rc7asIDlvPVetXcD7vUewOTFF9SJF2pAjvbjLdydSWbiFnfHd2eLpTb47kZKIWDCGTR+u4K9vPMhNUfF4ots1cdQiIiJiKyuwW9Ziv157qDc84HJhuvTBDBiG+db12ePxsGjhQtLS0pg/dRxXTp9FXB095Ytzs3n5wSlsXrmczMxMPB5P052QiIg0LmOCS0O3KUrIi8g3vF4vyf1SWLcsg0EXj6q9gzG832cEWxP6cOGm1zn367c5KW8D/1S9SJE240gv7r7sMJAvOwys8zi9uBMREWl6hytJQ6QbZ+gISOh02BFrqampZGRkMGbsWB6+bCgDR1zGwAvTiI7zcKC4kKxlGWQtz8TtdpOZmcnIkSOb9uRERERaKCXkRaSaMYZbJt7M1GnTKMnLqbM+NMBOT08WDrmeMWv+TueCrTw32M2nl92k8hMibcBRX9wdhiZ6ExERaTp2fxF2bVVJGv+3StKcgenRH+M6tlRAamoq27dtY968eTw1+2kW3PVK9bbkfinMmjmT9PR04uPjG+lMREQkZIwTXBq6TUE/BRGpIT09HbfbzeIHbsPv8x12vwMRbl4Yks57G7cRHRHOz+IPYHdubsJIRSQUql7cZb2dQUlezjEdUzXR2623TNSLOxERkUZiKysIbFqF//UXCCxfhM3bBYDp0hvngp/gumQ8Tu9TjjkZX8Xj8TB58mQ2rP+SvLw8tmzZQl5eHhvWf8nkyZOVjJd6O3jwIFdccQX9+vVjyJAhXHzxxWzerGdKkWajalLXhl5ECXkRqamqXuTmlcuZP3UcxbnZde5XnJvN36aN55qnX6T8tAtxOQ6BZQsJ/DczODRWRFqtY31xB5roTUREpDFZa7E52/G/PpfAG3/DbvgU/H6IjMY564c4l47HOe1CTHTMCX+WMQav10uvXr3wer16yS7HzVpLXl4eW7duJS8vD2stv/jFL9iwYQOff/45o0aN4sYbbwx1mCIijU4la0SkluOtF3nayJHYkn0EXnkOu2k1dusXOGMmYSKiQn0qItIINNGbiIhIaNn9xdisD7B5e2qWpOl3erAkTVh4qEMUqVZYWMjcuXOZ/fQcNm3cUL0+uV8Kt0y8mbPPPhuPx8NZZ53FI488EsJIRaQGYxqhZI1e5gIY24a6shYXFxMfH09RURFxcXGhDkek2SssLKyuF/ndG6dbb5lYq16k9fsI/PvPUFwAjgvnkuswSV1DEbrICWlr14v6nu/SpUsZM3YsZWVlR3xx99KiRZroTUSkFdD1MbSsrwK7JQv71eeHJmgFHBemY3fMgGEYtyZOl+anxv3iBWmc8q37xXXLMsh6OwO3282ihQuZP38+CQkJPP7446EOW+S4NLfrxYmqOp+C+X8gzh3dsG2XHSDhujtbzc+qvpSQF5GjstZSUFBASUkJsbGxJCQkHHGIamDtSuyqFQCYQd/HGfqDJopUpGG0tevFiZzv8b64ExGRlkvXx6ZnrYXcnQQ+e/tQEt4GexeGR+KcNgK8XVQ6RpqtpUuXkpaWRt/hIxh9z6PEJnastU9JXg6LH7iNjf9dRr9+/fj0009xu90hiFak/prD9aIhVSfk//5w4yTkr72j1fys6ksla0TkqKrqRXq93mPa3xk0HNulN4H/zMV+/h7+TatwRk/U0Nlm7rXXXmP69OkEAgF8Ph+333476enpoQ5Lmrmqid4mTZp0XC/uRERE5PCCJWlWYvN21yxJk3wapucA3VdLs1dYWMiYsWPpO3wE182chyus7vRTbGJHeg0dztZVH7Jz1y4qKiqUkBeRVk8JeRFpFMbbCefq2wgsfBzKSgn841GctJ9jPImhDk0I9rbKz8+ntLSUmJgYEhISuO6661ixYgWDBw9m69at9O/fn9GjRxMbq+HPcnTH++JOREREarK+SuzWLOzm1TVL0nTqiTn5LJWkkXqz1kL5figpwJbkg7cbTnxSo37m3LlzKSsrY/Q9jx42GQ/w3vw5rHljCb984T88+ZPzmTdvHpMnT27U2ETkGBmnEWrIN3B7LZQS8iLSaEx4BM4107Afv4ld/ymBf/8ZM2wkTsppoQ6tzTrchEp9k/tRXl7Ojh07GDx4MMXFxXi9XiIjI0MYrYhI0zl48CA/+clP+OKLL4iOjqZDhw7MmTOHvn37hjo0EWllbGUFJjwi+LW1kLcrWJLGV/lNSZqwQyVpErtqxJmcELvnK2zRXjhYBjYQfNlTVootKwGXC5yw4H9dYeC4gotxgv8OHeebhJxxwDGAOeq/SWsts5+ew8AL0uosU1OlKGc3r826l4Ruvfjnr28iPMrNHXfeyaRJk/TvXqQ5cMyh3/sGblOUkBeRxmWMwQwbie3Rj8Bb/8R++Dr+zWtwLr0e47hCHV6b8t0Jla654fYaEyod/Gozl19+OUlJSRw4cIDFixcTERER6rBFRBrcd0cJVY3s+MUvfsGll16KMYannnqKG2+8kRUrVoQ2WBFpNWwggF3/MfbrdZiU06EwF5u7q2ZJmr5DMb1OVkkaaRDWWmzeTqgsDybjwyKCCfmAH5u7vf7tVn1hqv/n0PfBr30+H/N/fRMJ3Xrh9q2lEocKXNX/Xe942ep4iO/YhRmf5VYfvuaNJSy4awIFBQUadSkirZoS8iLSJEznXjhjJhH412zI3UXgxZk4V/4S067tTuLRlI42odLJIy6jMHsnALu/WM3MmTO5/vrrWbt2LYmJKjMkIq3D4UYJJfdL4ZaJN5Oenl7dI++ss87ikUceCVWoItLK2IqDBFYth91fg68Cu+HT4AbHhenYAzNwuErSSIMzxsCA4cGXP/v2QFlRsAd8fBImsVvwZVDAH0zSH0rU4/dhAz7w+6Hqv37fN19Xs9/60n7rv5aA30+7qCiiw1yEWT9h+Immsnp3T6CcrSa+OoFfJTrOA0BJSYkS8iLNgUrWNBol5EWkyZgoN841U7HLF2N3bCSw+GmcH1yB6dk/1KG1ascyodKejevYX1jAbS/9l/lTxzH9nnvoe9JJrFq1iosvvjgEUYuINKyjjRKaOm0a99x7L4sWLiQ1NZXHH3+cUaNGhTpsEWkFbHEBgf+9CQU5EB4O4ZEQ8GMGnRPsDa/SHNKITFhEsPRRYlfswf1Qkg+ejpjww5emPNF/kaV5eZxyxkiu+cOfGXzRj3BhcQjgwuLCUoGrVjIe4EBxIYDmsBKRVk8JeRFpUsY4mAt+jN3yBYH3/01gxWJMrwGYH4zC6E1poziWCZXiO3ahJC+H/O1fc+X0Wfzhh6eyYcMGUlJSmjhaEZGGd7RRQoMuHkVJXg6LH7iNtLQ0rrvuOjZv3syyZctCFLGItCZ273YoLYSICOBQPV5XGCZJ9eGlaZmodhDVrtE/x+v1ktwvhXXLMhh08Sh8GODoz3pZyzJI7pdCQkJCo8coIsfAmDpfnp1wm6KEvIiEhul9Mk5SVwJL/oTd8gV252acH9+KiYwOdWityrFOqBTr7cCV02fx4l03YoxDRLSb2JgYunfv3oTRiog0vGMZJQQQm9iR62bO4/Grf8C8efP4+uuvcbvdTRytiLRGptfJmA7da06e6QrDuPQ4Lq2TMYZbJt7M1GnTKMnLOeJzSJXi3Gyylmcya+ZMvagSkVZP3VFFJGRMTDzOT6dCQifwVRJY+AQ2u/6TC0lt+fn5bNq4gVMuTKu1rU+Uj3PjKjCH6j+eeslo/m/hu/zqnyu4cvoscrL3UFBQ0NQhi4g0qGMZJVTlg388h8sVBsbwyiuvNFGEItLambAITJwXExOPiY7BREQpGS+tXnp6Om63m8UP3Ibf5zvivn6fjyUPTsHtdjNu3LgmilBEjspxGmcRJeRFJLSMy4XrRzdgvncxWEvgjb8T+GQZ1tqjHyxHVVpaCnwzQdK3JYYFSIn2MzaxnBqTMlFzQiURkZbqWEcJARTl7Oa1WfdScfAAEdHtuP2OOxg2bFgTRSoiItK6eDweFi1cyOaVy5k/dRzFudl17lecm838qePYtHI5Ly1ahMfjadpApVl47bXXOO200zj11FM55ZRTmDt3bqhDEmlUei0vIs2Cc/L3sF16Ech4Hpv1IXbjKpyxkzHhEaEOrUWLiYkBvpkg6ds+Lg1ngNtPrMtyafsK/rPvm4mdNKGSiLQGVaOErrnh9up1xlo6Vu7j9NJN5IR5+F9sPzCG+I5dmPFZLgBr3ljCgrsm8Nprr4UqdBERkRYvNTWVjIwMxowdy8OXDWXgiMsYeGFa9aTqWcsyyFqeidvtJjMzk5EjR4Y6ZGkMAT8Yp7p2uLWW/Px8SktLiYmJISEhgeuuu44VK1YwePBgtm7dSv/+/Rk9erSeR0OuEWrIn/C00a2DesiLSLNhPEk4P/k/iIiCynIC/3wMu29vqMNq0b49oVJthr/tjaLSQteIAOfEVVRv0YRKItIaVI0SiouP56QDu7lm79uMz3mDHxZ8RMeKAvqU191bT6OEREREGkZqairbt21j1syZHNi2ngV3TeCvE8ew4K4JHNi2nlkzZ7Jj+3Yl41urQADKiqCskNLCAh5//HFS+g8gKSmJ3r17k5SUREr/AZSXl7Njxw4AiouL8Xq9REZGHqVxaXTGaZxF1ENeRJoXExaB89Mp2M9WYLM+JPDqXzGnX4Az8MxQh9YiHW1CpQCGv+dGcV3SQVKi/ZT4fby3NU8TKolIi2fLy0gozeHjWXfRyZtLZNEBAPzGxc6ITqyO6UN+WFydvX40SkhERKTheDweJk+ezKRJkygoKKCkpITY2FgSEhL0vNHaGQOOC1/5AYpy9tIhLppBP7iI791we/VIiXXLMjj41WYuv/xykpKSOHDgAIsXLyYiQqPlpfVSQl5Emh1jDOb0EdhufQm88SL2f2/h37waJ+3nmgCrHtLT07nn3ntZ/MBtXDdzXq1JDX3W8I/cKH6SdJDT21WQsXSeJlQSkRbHWgv7i7Dbv8Tm7gC/n3ZY4mNjKCoqJrvDYL5092C/K/qobWmUkIiISMMzxuD1evF6vaEORZqKMazK+pKO8e2otHD5j0Yx8vIr+dsuOBgIvow5ecRlFGbvBGD3F6uZOXMm119/PWvXriUxMTGU0YtphJI1egkHqGSNiDRjpmN3nLG/grBw2JdLYMEsbGlRqMNqcY5lQqWD1vDCxmLyd+/g5isu5n/vLiM+3GhyXRFp1mwggC3IJvC/Nwi8s5DAx69hs7cEh0eHhWP6n8lbZTGc+svpLC/3HFMyvjg3m6zlmdx6y0T12hMRERE5AYWFhYy87HLyikpJ6tgJl+NQacH3rcfMPRvXsb+wgF/8+VX6Dh/B9HvuoXPnzqxatSp0gYs0shaRkN+6dSs33HADvXv3Jjo6mpNOOon77ruPioqKox8sIi2aiYzCuWYqps8p4PcReHkO9ut1oQ6rxamaUGnX5x/x8GVDWXDnjax5YwmbPlwRnLzwzhuZPvJUrr/pFnr07Elyt85wsBQqDoQ6dBGRGqyvErvna/zvvhRMwq9+G1ucF9wYm4Az5Hyc88bg+sGPcbr05Zpx6bjdbhY/cBt+n++Ibft9PpY8OEWjhEREREQawNy5c9m3r5DtkR2ptIYSH4QZ6PWtPhLxHbtQkpdD/vavuXL6LPbv38+GDRtISUkJXeAS5DiNs0jLKFmzfv16AoEAf/rTn+jbty/r1q1jwoQJ7N+/n0ceeSTU4YlIIzPGwfxgFLbXAALvvEzgvX/D11k4F47BaEKQY1Y1odK8efN4avbTLLjrleptyf1SmDVzJj+7/jpiAgegqmf8wf3YiGj1EhWRkLIHy7C7N2N3bICA79DfKAMuFyaxB6bnAGjnqfNvVdUoobS0NOZPHceV02cRl9Sp1n7Fudm8/OAUNq9cTmZmJh6Pp/FPTERERKSVstYy++k5DLwgjS/9sezNhoMB+HEnOC8BSnyWnApDrLcDV06fxYt33YgxDhHRbmJjYujevXuoT0Gk0RjbQusR/PGPf2TOnDl8/fXXx3xMcXEx8fHxFBUVERcX14jRiUhjsWUlBBY/A74KCI/AuWoiJqpdqMNqcay1dU6oZAMB2F8Y7BlvA8EZ0OMSMeFta4b7tna9aGvnK82ftRZKC7HbvsDm7wL/oZ7txoAThunRH9PlJEyk+5jbXLp0KWPGjqWsrIyBIy5j4IVp1ZOJZS3LIGt5Jm63m5cWLWLkyJGNdGYiLVtbu160tfMVEWlIeXl5JCUlcc0f/sygi0dVr+8QYbm8A+RVwis5tTtTrHljCQvumkBeXl6LmW+gtV0vqs6n4JU/Edfu6CUfj6vt/QdIGHVTq/lZ1VeL6CFfl6KioqNOtFVeXk55eXn198XFxY0dlog0MuOOxblmKoGl82HvTgKLnsK5cCymS+9Qh9aiHG5CJeM4EJuArSyHsuLgi4/yA9DGEvIi0vRswA/7cgh89Xnw70/AH9xgHAiPxOl7GiR1w4SF16v9YxkllJ6eTnx8fEOcjoiIiEibVlpaCkB0nKfG+r0VhkXZ9rA1tKv2LykpaTEJ+VbLmOC9eEO3KS0zIb9582aefPLJo5armTFjBvfff38TRSUiTcU4Dq5Lx2E3riLw4VICb/4D0+9UzFmXqLRKAzHhkdi4RKg4COERoQ5HRFopW1mB3bsd+9Uq8PuDI3MAHBcmPgnTZxDEdwi+LGwAHo+HyZMnM2nSpDpHCYmIiIhIw4iJiQHgQHFhrW3FvsPfd1XtHxsb2xhhiTQLIS2+fNddd2GMOeKyfv36Gsfs2rWLSy65hDFjxjBhwoQjtn/33XdTVFRUvezYsaMxT0dEmpjpNxRn1ARwubAbPiPw4iPBnt3SIIwxmMhojOMKdSgi0orYg/sJbF6F/51FBN7/F3bDx+DzgeNgOvfBGXYZznljcU6/GNO+U4Ml47+tapRQr1698Hq9SsaLiIiINDCv10tyvxTWLcs4ruOylmWQ3C/lqFUxpAkY0ziLhLaH/NSpUxk/fvwR9+nTp0/117t372bEiBGcffbZPPvss0dtPzIykshIlVkQac1MvBfnJ1MIvDwHykoI/PMxnEvGYRI7hzo0ERHhUD34kgLs1izsvuya9eBdYZgeJ2M698FENmx9ShEREREJHWMMt0y8manTplGSl0NsYsejHlOcm03W8kxmzZypDhPSqoU0IZ+UlERSUtIx7btr1y5GjBjB6aefzvPPP4/TCL2lRKRlMmFhuMZMIvD5e9jP3yfw2guYIedievSDinJMR83OLiLSlGzADwV7CGxeDQf316wHH+nG6TsUvF3qXQ9eRERERJq/9PR07rn3XhY/cBvXzZyHK+zwaUi/z8eSB6fgdrsZN25cE0Yph2WcRqghr3wutJAa8rt27eL888+nZ8+ePPLII+Tm5lZv69SpUwgjE5HmxBlyLrbrSQT+8zfs6nexq98Dvw/nsvFKyouINCBrLeRsxQYCOF1OCq6rLMdmb8VuWfOdevBhmPYdMb0HQXwiRjfhIiIiIm2Cx+Nh0cKFpKWlMX/qOK6cPou4pNp5vOLcbF5+cAqbVy4nMzMTj8fT9MGKNKEWkZB/88032bx5M5s3b6Zbt241tllrQxSViDRHJrELzphbCbw0GwrzICycwPuv4vzoRowmJxUROWG2spzAxv/B7q/AcREoysXu3XGoFI0FDpWi6dQH070/RMdqyLG0Oq+99hrTp08nEAjg8/m4/fbbSU9PD3VYIiIizU5qaioZGRmMGTuWhy8bysARlzHwwjSi4zwcKC4ka1kGWcszcbvdZGZmMnLkyFCHLFUcE1wauk1pGQn58ePHH7XWvIhItbBwsBbCIyAQgL07sZ8txwxLDXVkIiItmt2XQ+DLlVBSGPxbW1mO3fN1cOhpWBim1ymYTr0xEVGhDlWk0Vhrue6661ixYgWDBw9m69at9O/fn9GjRxMbGxvq8ERERJqd1NRUtm/bxrx583hq9tMsuOuV6m3J/VKYNXMm6enpxMfHhzBKkabTIhLyIiLHw4RF4IyagN22HvvVWsjPxm74DDvkHExUu1CHJyLSIgW2f4nd9BmUH4CIyOBKa6FdPM4ZqRiXbiuldbLWkp+fT2lpKTExMSQkJGCMobCwEIDi4mK8Xi+RkZGhDVRERKQZ83g8TJ48mUmTJlFQUEBJSQmxsbHV11VphlRDvtHoyUlEWiUTl4AZdDb2lOFQmAv7S5SMFxE5EZUVEBYBLldw9BFAZHSwJI2S8dIKFRYWMnfuXGY/PYdNGzdUr0/ul8LVV1/NlVdeSUxMDPv27WPx4sVERKg0noiIyNEYY/B6vXi93lCHIkdjTHBp6DZFCXkRad2MMdC+Q3AREZF6c04aAicNAQ7N4WMtBPzguEIcmUjDW7p0KWPGjqWsrIyBF6RxzQ23V9e6Xfvmv5kzZw7RbjcvvvgiCQkJ/OhHP2Lt2rUkJibW2Z71VUDFAXCFgysMXOHqDSgiIiLSRikhLyIiIiLHxVT1lnE05FRan6VLl5KWlkbf4SMYfc+jxCZ2rLG9fdee7Pryczr06UdaWhoZGRl069aNVatWcfHFF9fdaOk+OFj6rZ5mBusKg6hYTDvVy21oW7du5YEHHuDtt98mOzubLl26cN111/Gb3/xGIxlERESOlUrWNBol5EVERERERAiWqRkzdix9h4/gupnzcIXVflyK79iF0n15XHfrPACu+vGPCQ8LIyUlBTg0gsTvA185lJdBxUHABhcnDGwAAr7gKBN/ZROeXduxfv16AoEAf/rTn+jbty/r1q1jwoQJ7N+/n0ceeSTU4YmIiEgbp4S8iIiIiIgIMHfuXMrKyhh9z6N1JuMBYr0duHL6LP75m1/iBPw4WKbdehPdo8Hmbgsm2r+rqmd8wB/8PsIN7dpDRFQjnk3bdckll3DJJZdUf9+nTx82bNjAnDlzlJAXERE5RsaYBi+xp5J9QUrIi4iIiIhIm2etZfbTcxh4QVqtMjUOlh4RPnpE+OgVWcn4ay/Cdd2FGKB4b3awRrwNHEq8OxAeCZHu4H9dYeCrhH17gl+3aw+Rbj2QNrGioiISEhJCHYaIiIiIEvIiIiIiIiL5+fls2riBa264vda2k6MrGNbuIFUp9IAFnzXk+1y893UBT02fwrv/XYn3MJO6Eh6J9XYDx6VEfAhs3ryZJ5988qi948vLyykvL6/+vri4uLFDExERab5UQ77R6Kcg0spZvw9bWRHqMERERESatdLSUgCi4zy1tm04GMEHpdG8UtiOeflx/DU/nrn5cWQUteN/eeV8sXEzJYeOPxzjClMy/gTddddd1cPnD7esX7++xjG7du3ikksuYcyYMUyYMOGI7c+YMYP4+PjqpXv37o15OiIiItJGKSEv0toV5kDedmxhTnA4tYiIiIjUEhMTA8CB4sJa2yqt4cuDEeT6wqiwNZPqVfvHxsY2doht3tSpU/nyyy+PuPTp06d6/927dzNixAjOPvtsnn322aO2f/fdd1NUVFS97NixozFPR0REpHmr6iHf0Mtx+O1vf1vr5Xv//v2rtx88eJBbbrkFr9dLTEwMV111FTk5OQ39k2hwKlkj0tpFtYPy/bC/EA6UYN1xEJekHloiIiIi3+L1eknul8K6ZRkMunjUMR+XtSyD5H4pqk/eBJKSkkhKSjqmfXft2sWIESM4/fTTef7553GcoycAIiMjiYyMPNEwRUREWgdjwGng3FE9clEDBw7krbfeqv4+LOybdPZtt91GZmYmixYtIj4+nltvvZXRo0fz3//+t0HCbSxKyIu0dtFxULoP/D4I+OFAMcQkBCcVExEREREAjDHcMvFmpk6bRkleTq2JXetSnJtN1vJMZs2cqc4OzciuXbs4//zz6dmzJ4888gi5ubnV2zp16hTCyEREROR4hYWF1Xn9Lioq4i9/+QsvvvgiF1xwAQDPP/88AwYM4MMPP+Sss85q6lCPmUrWiLRyxnGgnQew4DiAAzYQ4qhEREREmp/09HTcbjeLH7gNv893xH39Ph9LHpyC2+1m3LhxTRShHIs333yTzZs3s2zZMrp160bnzp2rFxERETlGjViypri4uMby7UnVv2vTpk106dKFPn36cO2117J9+3YAPv30UyorK7nooouq9+3fvz89evRg5cqVjfuzOUFKyIu0Be44cMcHFyzk71Q9eZFWYOvWrdxwww307t2b6OhoTjrpJO677z4qKvT7LSJSHx6Ph0ULF7J55XLmTx1HcW52nfsV52Yzf+o4Nq1czkuLFuHxeJo2UDmi8ePHY62tcxEREZHQ6969e42J1GfMmFHnfsOGDeOFF17g9ddfZ86cOWzZsoVzzz2XkpISsrOziYiIqHUf1rFjR7Kz676Hay5Us0KkDTCOCzzBYdc2IhqK9gaT8t7umLDwEEcnIvW1fv16AoEAf/rTn+jbty/r1q1jwoQJ7N+/n0ceeSTU4YmItEipqalkZGQwZuxYHr5sKANHXMbAC9OIjvNwoLiQrGUZZC3PxO12k5mZyciRI0MdsoiIiEjDM6ZeNd+P2iawY8cO4uLiqlcfbg6XSy+9tPrrwYMHM2zYMHr27MnChQuJjo5u2NiakBLyIm2MiY4N9g4qzoX8HdjE7hjX0ZPyr7/+OtOnT6eiogK3282f/vQnhgwZ0gQRi8jhXHLJJVxyySXV3/fp04cNGzYwZ84cJeRFRE5Aamoq27dtY968eTw1+2kW3PVK9bbkfinMmjmT9PR04uPjQxiliIiISMsUFxdXIyF/rDweD/369WPz5s1cfPHFVFRUUFhYWKOXfE5OTrOfM0YJeZE2yLjjsFgozoO8HdjEHphvTfJqrSU/P5/S0lJiYmJwHIdrr72Wd999l4EDB/Lee+9x7bXXsm7duhCehYjUpaioiISEhCPuU15eXqNGX3FxcWOHJSLS4ng8HiZPnsykSZMoKCigpKSE2NhYEhISNIGriIiItH7GVNd8b9A2T0BpaSlfffUV119/Paeffjrh4eEsW7aMq666CoANGzawfft2hg8f3hDRNhrVkBdpo4w7HmK9YC3kbcf6fRQWFvL444+T0n8ASUlJ9O7dm6SkJE4dehoul4uuXbsCcO6557J9+3Y+++yzEJ+FiHzb5s2befLJJ7npppuOuN+MGTNq1Ovr3r17E0UoItLyGGPwer306tULr9erZLyIiIi0DVUlaxp6OQ7Tpk3jnXfeYevWrXzwwQdceeWVuFwufvrTnxIfH88NN9zAlClTWL58OZ9++ik/+9nPGD58OGeddVYj/VAahnrIi7Rhpp0n2FO+pIDir7MYcmEau/ZkM/CCNK654fbqWqmfv/4yO5Zn0rVrVxYvXkx5eTklJSVs3bqV0047LdSnIdLq3HXXXfzhD3844j5ffvkl/fv3r/5+165dXHLJJYwZM4YJEyYc8di7776bKVOmVH9fXFyspLyIiIiIiIg0Kzt37uSnP/0p+fn5JCUlcc455/Dhhx+SlJQEwKOPPorjOFx11VWUl5eTmprK008/HeKoj04JeZE2zrRrzxdZX8D+ffznxb+yuLwLYQkda+wz6OJRrH3rVV5+cAqXXHIJl19+OSeffDJhYfoTItIYpk6dyvjx44+4T58+faq/3r17NyNGjODss8/m2WefPWr7kZGRh500R0RERERERATjNELJmuNr7x//+McRt0dFRTF79mxmz559IlE1OWXTRNq4wsJCzrr4h9x55x1M+OmPuRHDi0UBKmzNP5KDLrqck8+/lPlTx7F8xQpcjsPJJ58coqhFWrekpKTqN/5Hs2vXLkaMGMHpp5/O888/j+OoGp2IiIiIiIhIc6WndpE2bu7cuZSVlVH2vStYVx6Ny8A18YVEmECN/Ypzs3GFhXHl9FnsLy2lZ8+e9O3bN0RRiwgEk/Hnn38+PXr04JFHHiE3N5fs7Gyys7NDHZqIiIiIiIi0ZI5pnEXUQ16kLbPWMvvpOQy8II3YxI58fABcxnJyZDnXxBfy98L2VBL8Y/nWM39g66oP8ft8xHfqSun+Mqy1mthMJITefPNNNm/ezObNm+nWrVuNbdbaEEUlIiIiIiIiIoejHvIibVh+fj6bNm7glAvTqtetLGvHhvJIHAPdIyqq14++51GmLF7J7f/+hEt/dR9ff7WZgoKCUIQtIoeMHz8ea22di4iIiIiIiEi9VdWQb+hF1ENepC0rLS0FIDrOU2P9+2XtWH0wioOBuv9QVu1fUlKC1+ttzBBFRERERERERERaDSXkRdqwmJgYAA4UF9baVhpwHfa4qv1jY2MbIywREREREREREQklY4JLQ7cpKlkj0pZ5vV6S+6WwblnGcR2XtSyD5H4pJCQkNFJkIiIiIiIiIiISMipZ02j0UxBpw4wx3DLxZrLezqAkL+eYjinOzSZreSa33jJRE7qKiIiIiIiIiIgcByXkRdq49PR03G43ix+4Db/Pd8R9/T4fSx6cgtvtZty4cU0UoYiIiIiIiIiINKmqkjUNvYgS8iJtncfjYdHChWxeuZz5U8dRnJtd537FudnMnzqOTSuX89KiRXg8nqYNVEREREREREREpIXTpK4iQmpqKhkZGYwZO5aHLxvKwBGXMfDCNKLjPBwoLiRrWQZZyzNxu91kZmYycuTIUIcsIiIiIiIiIiKNpTFqvquGPKCEvIgckpqayvZt25g3bx5PzX6aBXe9Ur0tuV8Ks2bOJD09nfj4+BBGKSIiIiIiIiIi0nIpIS8i1TweD5MnT2bSpEkUFBRQUlJCbGwsCQkJmsBVREREREREGtTrr7/O9OnTqaiowO1286c//YkhQ4aEOiwRAXCc4NLQbYoS8iJSmzEGr9eL1+sNdSgiIiIiIiLSClhryc/Pp7S0lJiYGBzH4dprr+Xdd99l4MCBvPfee1x77bWsW7cu1KGKCMHcUEN3zlRnzyC9lhARERERERERkUZRWFjI448/Tkr/ASQlJdG7d2+SkpI4dehpuFwuunbtCsC5557L9u3b+eyzz0IcsYhI41IPeRERERERERERaXBLly5lzNixlJWVMfCCNK654Xai4zwcKC7k89dfZsfyTLp27crixYspLy+npKSErVu3ctppp4U6dBExphEmdVUPeVBCXkREREREREREGtjSpUtJS0uj7/ARjL7nUWITO9bYPujiUax961VefnAKl1xyCZdffjknn3wyYWFKVYlI69am/spZawEoLi4OcSQiItKcVV0nqq4bIiIiIiJy7AoLCxkzdix9h4/gupnzcB0myT7ooss5+fxLmT91HMtXrMDlOJx88slNHK2I1MmYhu/Rrh7yQBtLyJeUlADQvXv3EEciIiItQUlJCfHx8aEOQ0RERESkRZk7dy5lZWWMvufRwybjAYpzs4lL6sSV02fx0CWDGTRoEH379m3CSEVEml6bSsh36dKFHTt2EBsb22xm9S0uLqZ79+7s2LGDuLi4UIfTKNrCOULbOE+dY+vRFs7zRM7RWktJSQldunRppOhERERERFonay2zn57DwAvSapWpAQt8k49565k/sHXVh/h9PuI7daV0fxnW2maTsxFp25yGryFPQ7fXMrWphLzjOHTr1i3UYdQpLi6u1SbFqrSFc4S2cZ46x9ajLZxnfc9RPeNFRERERI5ffn4+mzZu4JobbgfA7QQY4q4kJaoSY2BxgZsifzApN/qeR6uPW/PGEhbcNYGCggK8Xm9IYhcRaQptKiEvIiIiIiIiIiKNp7S0lERvAleekcL3E0sJO9TZ3QL7fA7F/rp7v0fHeYBg2Ugl5EWaAdWQbzRKyIuIiIiIiIiIyHGxfh84DuZQSQsb8MOBErpGwzsvLyCuQzwuA5UW3i+JZGt5GAEOn4w7UFwIQGxsbFOELyJH4zjBpaHbFCXkQy0yMpL77ruPyMjIUIfSaNrCOULbOE+dY+vRFs6zLZyjiIiIiEhTs9ZC+X4o3QeuMGyEGw6WgLUAhLlc+AOWh/66gB4/ue2ISfhvy1qWQXK/FBISEhozfBGRkDPWHvqLKSIiIm1ScXEx8fHxFBUVtfo5BUTgUCLBXwmVByEsAhMeFeqQRFqEtna9aGvnK3IsbCAA+/fBwdJgAt6YbyZ9NAbatYdIN0888QRTp03jztdW1zGxa23Fudk8fNlQZs2cyeTJkxv5LEQaVmu7XlSdT+Ga94mLjWnYtktK8Qw+p9X8rOpL4wREREREpNWzAT/2QAm2KBfytkP+TijaG+zdJyIiIkdl/T4oyoEDJd8k462FiCjwdsV4u2Gi2mGMIT09Hbfb/f/bu/+gqK/73+OvBYNCZJcgIFIhqETrT8wQJRBNXaOiNz/kmwnpvfUbMOU6HYokVpOKXhMy840TW0w0BoukNxEy1WryraiDTTThCnbGH6CJKeIXUxKtij8CtS6IVSK7949EvrEm1B+7exZ4PmY+I3w+u2de5yh8dt6ezzna9B+/UPuVK522237lija/PF9BQUFKT0/3Um8AwBwK8gAAAOj+Ws9/U0RwSO1XJGe75NdLCmbTOAAAbojF8s390//rw+L39Z8BgR3ryF8VEhKi9959V/V7dup3C9LV3HjmO5tsbjyj3y1I11/27NR/vveeQkJCvNARADfEULFa7AAAHLdJREFU4ueZA6whDwAAgB7Av9fXhYSrLP6SLUKWXgHmMgEA0IVY/PylfgNv+PUpKSkqKytT2pNP6tcP36uR9oc18qFHFGgN0T+az6u2vEy1O7cpKChI27Zt07Rp0zyYHgB8BwV5AAAAdFkffPCBlixZora2NgUFBamoqEjx8fEd110ul9T8pXT5oqRvZvZZLFLfUFl6B5kLDgBAD5CSkqLjf/2r3nnnHRWs/o1+n7ul49o9Q4fptVdfVUZGhmw2m8GUAL6TxXLthBZ3tQmWrPEljz32mGJiYtSnTx8NGDBATz31lE6dOmU6llsdO3ZMmZmZGjRokAIDAzVkyBDl5eWpra3NdDS3Wrp0qZKTkxUUFNStHrlbvXq1YmNj1adPHyUmJqqqqsp0JLfatWuXHn30UUVFRclisWjz5s2mI7nVK6+8onHjxik4OFgRERFKTU3VkSNHTMdyu8LCQo0ZM0ZWq1VWq1VJSUl6//33TccC4AF///vfNWvWLJWUlOjPf/6z8vPzNWvWrI7rrrZ/SI1/lS61SrJIIf2lO/pIgVbpzhBjuQEA6ElCQkL0zDPP6Ejdf6mpqUlHjx5VU1OTjtT9l5555hmK8YDPsnjoAAV5H2K32/Xuu+/qyJEj+sMf/qDPP/9cTzzxhOlYblVXVyen06mioiLV1tZqxYoVWrNmjRYvXmw6mlu1tbUpLS1NWVlZpqO4zcaNGzV//nzl5eXp448/Vnx8vFJSUvTll1+ajuY2ra2tio+P1+rVq01H8YjKykplZ2dr7969+vDDD/XVV19p2rRpam1tNR3NrQYOHKhly5bpwIED2r9/vyZPnqyZM2eqtrbWdDQAt8nlcqmpqUnHjh1TU1OT6uvr1a9fP40cOVKSNHHiRB0/flwH9u+X61yD9PfTklxSYLAUfrcsve+UJSxaFluELMzOAQDAqywWi/r166fY2Fj169ePezGAHsvicrlcpkPgu23dulWpqam6fPmy7rjjDtNxPCY/P1+FhYX64osvTEdxu+LiYs2bN0/nz583HeW2JSYmaty4cSooKJAkOZ1ORUdHKycnR7m5uYbTuZ/FYlFpaalSU1NNR/GYxsZGRUREqLKyUg8++KDpOB4VGhqq/Px8ZWZmmo7ik5qbm2Wz2eRwOGS1Wk3HAa5z/vx5lZSUaPVvCvWXz/77yZ7BQ+J05vQpbdq0SSkpKdq6datmzpyp/3z7N3r8f6R8vWlUaBTrxANu0tPuFz2tvwCAW9Pd7hdX+3O+dp+swX3d23bLBYWMTOw2Y3WrWEPeR507d07r1q1TcnJyty7GS5LD4VBoaKjpGOhEW1ubDhw4oEWLFnWc8/Pz05QpU7Rnzx6DyXA7HA6HJHXrn7/29na99957am1tVVJSkuk4AG7B9u3blfbkk7p48aJGTn5EP8l8vmMzuEPlZbp09As9/PDDGjx4kKZOTNaIofeol38vqe9dUlAIs+8AAAAA+BQK8j5m4cKFKigo0MWLF3X//ferrKzMdCSPqq+v1xtvvKHly5ebjoJONDU1qb29Xf3797/mfP/+/VVXV2coFW6H0+nUvHnz9MADD2jUqFGm47hdTU2NkpKSdOnSJfXt21elpaUaMWKE6VgAbtL27dv1yCOPKC7JrsdfWKHgsGvvQ6OnzlRL08vSnzbqf9rHK2pAlOL+sFkjEifKcuddhlIDAAAA3QCbunoMa8h7WG5uriwWS6fHtwuazz//vD755BPt2LFD/v7+Sk9PV1dYVehm+ylJDQ0Nmj59utLS0jRnzhxDyW/crfQR8FXZ2dk6dOiQNmzYYDqKRwwbNkwHDx7Uvn37lJWVpYyMDB0+fNh0LAA34fz580p78knFJdn176++c10xXpKC/dqVFuLQLzKfUkDgnZr0b/9LEyc+qHuG/dBAYgAAAAD415gh72ELFizQ7NmzO33N4MGDO74OCwtTWFiYhg4dquHDhys6Olp79+71+aUWbrafp06dkt1uV3Jyst58800Pp3OPm+1jdxIWFiZ/f3+dPXv2mvNnz55VZGSkoVS4VXPnzlVZWZl27dqlgQMHmo7jEQEBAYqLi5MkJSQkqLq6Wq+//rqKiooMJwNwo0pKSnTx4kU9/sIK+fe69iOrRS7df+c/NKJPm+YvXKndVQf090tf6fzpk5qV8bShxAAAAEB3YvnmcHeboCDvYeHh4QoPD7+l9zqdTknS5cuX3RnJI26mnw0NDbLb7UpISNDatWvl59c1HtS4nb/Lri4gIEAJCQkqLy/v2OTU6XSqvLxcc+fONRsON8zlciknJ0elpaWqqKjQoEGDTEfyGqfT2SV+lwL4msvl0urfFGrk5Eeumxl/l3+7ZtpadIfFpSsui1L+z+sa+dXX++38fuH/1ttri7Vw4ULWjgcAAADgkyjI+4h9+/apurpaEyZM0F133aXPP/9cL7zwgoYMGeLzs+NvRkNDgyZNmqS7775by5cvV2NjY8e17jTT+vjx4zp37pyOHz+u9vZ2HTx4UJIUFxenvn3du0O1t8yfP18ZGRm67777NH78eK1cuVKtra16+unuMxPxwoULqq+v7/j+6NGjOnjwoEJDQxUTE2MwmXtkZ2dr/fr12rJli4KDg3XmzBlJks1mU2BgoOF07rNo0SLNmDFDMTExamlp0fr161VRUaHt27ebjgbgBv3tb3/TXz47op9kPn/dtRF9Lsvf4tLxtjv0Ucudav/WLJuRDz2i3+du0blz59SvXz9vRgYAAAC6F9aQ9xgK8j4iKChImzZtUl5enlpbWzVgwABNnz5dS5YsUe/evU3Hc5sPP/xQ9fX1qq+vv26pjK6wVv6NevHFF1VSUtLx/b333itJ2rlzpyZNmmQo1e358Y9/rMbGRr344os6c+aMxo4dqw8++OC6jV67sv3798tut3d8P3/+fElSRkaGiouLDaVyn8LCQkm67t/g2rVr/+VyTF3Jl19+qfT0dJ0+fVo2m01jxozR9u3bNXXqVNPRANygCxcuSJICrSHXXdvbGqiD/+ijVuf1T9hdfX1LSwsFeQAAAOB2sGKNx1hc3akKCgAAblpzc7NsNpscDoesVqvpOICampoUHh6un/zq/2r01Jk3/L4/79is3+fOUVNTEwV5wAN62v2ip/UXAHBrutv94mp/ztftlzXYvas8NLdcUMgP7+s2Y3Wrusbi3QAAAOgx+vXrp3uGDtOh8rKbel9teZnuGTpMoaGhHkoGAAAA9BQWDx2gIA8AAACfYrFYlP3zLNX+vzK1NJ29ofc0N55R7c5tmpv9czZ0BQAAAOCzWEMeAAAAPicjI0MvvPiiNv3HL/Tvr74j/17f/7G1/coVbX55voKCgpSenu7FlAC6s6uruzY3NxtOAgDwZVfvE91uVXA2dfUYCvIAAADwOSEhIXrv3Xf1yCOP6HcL0vVvS16TNTzyutc1N55R6cvzVb9np7Zt26aQkBDvhwXQLbW0tEiSoqOjDScBAHQFLS0tstlspmOgC6AgDwAAAJ+UkpKisrIypT35pH798L0aaX9YIx96RIHWEP2j+bxqy8tUu3ObgoKCtG3bNk2bNs10ZADdSFRUlE6cOKHg4OAbXgqrublZ0dHROnHiRI/brI6+03f63nPQ92v77nK51NLSoqioKMPp3MwiD8yQd29zXRUFeQAAAPislJQUHf/rX/XOO++oYPVv9PvcLR3X7hk6TK+9+qoyMjKYjQTA7fz8/DRw4MBbeq/Vau1xRaqr6Dt972noO32X1E0/i3piE1Yq8hIFeQAAAPi4kJAQPfPMM8rJydG5c+fU0tKi4OBghYaGsoErAAAAgC6FgjwAAAC6BIvFon79+qlfv36mowAAAADdG5u6eoyf6QAAAAAAAHQHvXv3Vl5ennr37m06itfRd/re09B3+g7cKovL5XKZDgHAu9rb2zVx4kRFRkZq06ZNHecdDodGjRql9PR0LV261GBCAN7U3Nwsm80mh8PRY9eABAD8a9wvAADo/q7e78//5VNZg4Pd23ZLi0Luie/xnyWYIQ/0QP7+/iouLtYHH3ygdevWdZzPyclRaGio8vLyDKYDAAAAAAAAuifWkAd6qKFDh2rZsmXKycnR5MmTVVVVpQ0bNqi6uloBAQGm4wEAAAAAAMAU1pD3GAryQA+Wk5Oj0tJSPfXUU6qpqdGLL76o+Ph407EAAAAAAACAbomCPNCDWSwWFRYWavjw4Ro9erRyc3NNRwIAAAAAAIBpzJD3GNaQB3q4t99+W0FBQTp69KhOnjxpOg4AAADQLTz22GOKiYlRnz59NGDAAD311FM6deqU6Vged+zYMWVmZmrQoEEKDAzUkCFDlJeXp7a2NtPRvGLp0qVKTk5WUFCQQkJCTMfxqNWrVys2NlZ9+vRRYmKiqqqqTEfyil27dunRRx9VVFSULBaLNm/ebDqS17zyyisaN26cgoODFRERodTUVB05csR0LK8oLCzUmDFjZLVaZbValZSUpPfff990LA+zeOgAM+SBHmz37t1asWKFduzYoZdfflmZmZn66KOPZOF/LIEexeVySZKam5sNJwEA+LKr94mr9w10zm63a/HixRowYIAaGhr03HPP6YknntDu3btNR/Oouro6OZ1OFRUVKS4uTocOHdKcOXPU2tqq5cuXm47ncW1tbUpLS1NSUpLeeust03E8ZuPGjZo/f77WrFmjxMRErVy5UikpKTpy5IgiIiJMx/Oo1tZWxcfH66c//akef/xx03G8qrKyUtnZ2Ro3bpyuXLmixYsXa9q0aTp8+LDuvPNO0/E8auDAgVq2bJnuueceuVwulZSUaObMmfrkk080cuRI0/HQxVhcfJoCeqSLFy9q7Nixmj59ulatWqVjx45p9OjR+vWvf62srCzT8QB40cmTJxUdHW06BgCgizhx4oQGDhxoOkaXs3XrVqWmpury5cu64447TMfxqvz8fBUWFuqLL74wHcVriouLNW/ePJ0/f950FI9ITEzUuHHjVFBQIElyOp2Kjo5WTk5Oj1oK1WKxqLS0VKmpqaajGNHY2KiIiAhVVlbqwQcfNB3H60JDQ5Wfn6/MzEzTUdyqublZNptNji9qZQ0Odm/bLS2yDR4ph8Mhq9Xq1ra7EmbIAz3UokWL5HK5tGzZMklSbGysli9frueee04zZsxQbGys2YAAvCYqKkonTpxQcHCwkSdkmpubFR0drRMnTvToD2Xfh/HpHOPTOcanc4xP5/55fFwul1paWhQVFWU6Wpdz7tw5rVu3TsnJyT2uGC9JDodDoaGhpmPATdra2nTgwAEtWrSo45yfn5+mTJmiPXv2GEwGb3M4HJLU436+29vb9d5776m1tVVJSUmm46ALoiAP9ECVlZVavXq1KioqFBQU1HH+Zz/7mTZt2sTSNUAP4+fn5xMzHa+ux4jvxvh0jvHpHOPTOcanc98eH5vNZjhN17Jw4UIVFBTo4sWLuv/++1VWVmY6ktfV19frjTfe6BHL1fQUTU1Nam9vV//+/a85379/f9XV1RlKBW9zOp2aN2+eHnjgAY0aNcp0HK+oqalRUlKSLl26pL59+6q0tFQjRowwHctz2NTVY9jUFeiBfvSjH+nKlSuaMGHCdde2b9+u8vJyivEAAADAP8nNzZXFYun0+HZB8vnnn9cnn3yiHTt2yN/fX+np6V12Df6b7bskNTQ0aPr06UpLS9OcOXMMJb99t9J3oLvLzs7WoUOHtGHDBtNRvGbYsGE6ePCg9u3bp6ysLGVkZOjw4cOmY6ELYoY8AAAAAAA3YMGCBZo9e3anrxk8eHDH12FhYQoLC9PQoUM1fPhwRUdHa+/evV1yiYOb7fupU6dkt9uVnJysN99808PpPOtm+97dhYWFyd/fX2fPnr3m/NmzZxUZGWkoFbxp7ty5Kisr065du3ziSVtvCQgIUFxcnCQpISFB1dXVev3111VUVGQ4madYvjnc3SYoyAMAAKN69+6tvLw89e7d23QUn8T4dI7x6Rzj0znGp3OMz/XCw8MVHh5+S+91Op2SpMuXL7szktfcTN8bGhpkt9uVkJCgtWvXys+vaz+cfzt/791RQECAEhISVF5e3rGZqdPpVHl5uebOnWs2HDzK5XIpJydHpaWlqqio0KBBg0xHMsrpdHbZ3+k3xgNL1lCQlyRZXF31eTkAAAAAAHzQvn37VF1drQkTJuiuu+7S559/rhdeeEFnz55VbW1tt/5PjoaGBk2aNEl33323SkpK5O/v33GtJ8yePn78uM6dO6etW7cqPz9ff/rTnyRJcXFx6tu3r+F07rNx40ZlZGSoqKhI48eP18qVK/Xuu++qrq7uurXlu5sLFy6ovr5eknTvvffqtddek91uV2hoqGJiYgyn86yf//znWr9+vbZs2aJhw4Z1nLfZbAoMDDSYzPMWLVqkGTNmKCYmRi0tLVq/fr1+9atfafv27Zo6darpeG7V3Nwsm80mx9E6Wa3Bbm67RbZBP5TD4ejR+/dQkAcAAAAAwI1qamr07LPP6tNPP1Vra6sGDBig6dOna8mSJfrBD35gOp5HFRcX6+mnn/7Oaz2h/DB79myVlJRcd37nzp2aNGmS9wN5UEFBgfLz83XmzBmNHTtWq1atUmJioulYHldRUSG73X7d+YyMDBUXF3s/kBd9315za9eu/ZfLOnV1mZmZKi8v1+nTp2Wz2TRmzBgtXLiw2xXjpW8V5I8d8UxBPnYYBXkK8gAAAAAAAAAACvKexxryAAAAAAAAAIBvYVNXT+naO6sAAAAAAAAAANBFUJAHAAA+4dixY8rMzNSgQYMUGBioIUOGKC8vT21tbaaj+YylS5cqOTlZQUFBCgkJMR3HJ6xevVqxsbHq06ePEhMTVVVVZTqST9i1a5ceffRRRUVFyWKxaPPmzaYj+YxXXnlF48aNU3BwsCIiIpSamqojR46YjuUzCgsLNWbMGFmtVlmtViUlJen99983HQsAAHibxeKZAxTkAQCAb6irq5PT6VRRUZFqa2u1YsUKrVmzRosXLzYdzWe0tbUpLS1NWVlZpqP4hI0bN2r+/PnKy8vTxx9/rPj4eKWkpOjLL780Hc241tZWxcfHa/Xq1aaj+JzKykplZ2dr7969+vDDD/XVV19p2rRpam1tNR3NJwwcOFDLli3TgQMHtH//fk2ePFkzZ85UbW2t6WgAAADdApu6AgAAn5Wfn6/CwkJ98cUXpqP4lOLiYs2bN0/nz583HcWoxMREjRs3TgUFBZIkp9Op6Oho5eTkKDc313A632GxWFRaWqrU1FTTUXxSY2OjIiIiVFlZqQcffNB0HJ8UGhqq/Px8ZWZmmo4CAAA8rGNT1+N/8cymrjH39PhNXZkhDwAAfJbD4VBoaKjpGPBBbW1tOnDggKZMmdJxzs/PT1OmTNGePXsMJkNX43A4JInfNd+hvb1dGzZsUGtrq5KSkkzHAQAAXmXx0IFepgMAAAB8l/r6er3xxhtavny56SjwQU1NTWpvb1f//v2vOd+/f3/V1dUZSoWuxul0at68eXrggQc0atQo03F8Rk1NjZKSknTp0iX17dtXpaWlGjFihOlYAAAA3QIz5AEAgEfl5ubKYrF0evxzAbWhoUHTp09XWlqa5syZYyi5d9zK+ABwj+zsbB06dEgbNmwwHcWnDBs2TAcPHtS+ffuUlZWljIwMHT582HQsAADgTWzq6jHMkAcAAB61YMECzZ49u9PXDB48uOPrU6dOyW63Kzk5WW+++aaH05l3s+ODr4WFhcnf319nz5695vzZs2cVGRlpKBW6krlz56qsrEy7du3SwIEDTcfxKQEBAYqLi5MkJSQkqLq6Wq+//rqKiooMJwMAAOj6KMgDAACPCg8PV3h4+A29tqGhQXa7XQkJCVq7dq38/Lr/w3w3Mz74bwEBAUpISFB5eXnHZqVOp1Pl5eWaO3eu2XDwaS6XSzk5OSotLVVFRYUGDRpkOpLPczqdunz5sukYAAxpb2/XxIkTFRkZqU2bNnWcdzgcGjVqlNLT07V06VKDCQF4hCdmtDNDXhIFeQAA4CMaGho0adIk3X333Vq+fLkaGxs7rjHj+WvHjx/XuXPndPz4cbW3t+vgwYOSpLi4OPXt29dsOAPmz5+vjIwM3XfffRo/frxWrlyp1tZWPf3006ajGXfhwgXV19d3fH/06FEdPHhQoaGhiomJMZjMvOzsbK1fv15btmxRcHCwzpw5I0my2WwKDAw0nM68RYsWacaMGYqJiVFLS4vWr1+viooKbd++3XQ0AIb4+/uruLhYY8eO1bp16zRr1ixJUk5OjkJDQ5WXl2c4IQB0LRaXy+UyHQIAAKC4uPh7C6l8XPna7NmzVVJSct35nTt3atKkSd4P5AMKCgqUn5+vM2fOaOzYsVq1apUSExNNxzKuoqJCdrv9uvMZGRkqLi72fiAfYvmemVlr1679l8tH9QSZmZkqLy/X6dOnZbPZNGbMGC1cuFBTp041HQ2AYatWrdJLL72k2tpaVVVVKS0tTdXV1YqPjzcdDYAbNTc3y2azyXHyqKzWYDe33SLbwEFyOByyWq1ubbsroSAPAAAAAACATrlcLk2ePFn+/v6qqalRTk6OlixZYjoWADejIO95LFkDAAAAAACATlksFhUWFmr48OEaPXq0cnNzTUcC4EkWeWANefc211V1/53SAAAAAAAAcNvefvttBQUF6ejRozp58qTpOAA86eqmru4+QEEeAAAAAAAAndu9e7dWrFihsrIyjR8/XpmZmezzAwC3gII8AAAAAAAAvtfFixc1e/ZsZWVlyW6366233lJVVZXWrFljOhoAj7F46AAFeQAAAAAAAHyvRYsWyeVyadmyZZKk2NhYLV++XL/85S917Ngxs+EAoIuxuHi+CAAAAAAAAN+hsrJSDz30kCoqKjRhwoRrrqWkpOjKlSv66KOPZGFtaKBbaG5uls1mk+P0cVmtVve3PSBGDofD7W13JRTkAQAAAAAAAAAdBfkTn9XKGhzs3rZbWhQ9dGSPL8j3Mh0AAAAAAAAAAGBeQECAIiMjFT10pEfaj4yMVEBAgEfa7iqYIQ8AAABIam9v18SJExUZGalNmzZ1nHc4HBo1apTS09O1dOlSgwkBAAAAz7t06ZLa2to80nZAQID69Onjkba7CgryAAAAwDc+++wzjR07Vr/97W81a9YsSVJ6ero+/fRTVVdX9/jZPAAAAABuDwV5AAAA4FtWrVqll156SbW1taqqqlJaWpqqq6sVHx9vOhoAAACALo6CPAAAAPAtLpdLkydPlr+/v2pqapSTk6MlS5aYjgUAAACgG6AgDwAAAPyTuro6DR8+XKNHj9bHH3+sXr16mY4EAAAAoBvwMx0AAAAA8DVvv/22goKCdPToUZ08edJ0HAAAAADdBDPkAQAAgG/ZvXu3fvSjH2nHjh16+eWXJUkfffSRLBaL4WQAAAAAujpmyAMAAADfuHjxombPnq2srCzZ7Xa99dZbqqqq0po1a0xHAwAAANANMEMeAAAA+Mazzz6rP/7xj/r0008VFBQkSSoqKtJzzz2nmpoaxcbGmg0IAAAAoEujIA8AAABIqqys1EMPPaSKigpNmDDhmmspKSm6cuUKS9cAAAAAuC0U5AEAAAAAAAAA8ALWkAcAAAAAAAAAwAsoyAMAAAAAAAAA4AUU5AEAAAAAAAAA8AIK8gAAAAAAAAAAeAEFeQAAAAAAAAAAvICCPAAAAAAAAAAAXkBBHgAAAAAAAAAAL6AgDwAAAAAAAACAF1CQBwAAAAAAAADACyjIAwAAAAAAAADgBRTkAQAAAAAAAADwAgryAAAAAAAAAAB4wf8H6zgRzoH7tNoAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1500x500 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "data_path = configs['data'].get(\"path\",None) # 数据集路径\n",
    "print(configs)\n",
    "print(data_path)\n",
    "data = np.load(data_path, allow_pickle=True)\n",
    "\n",
    "# 取前3个样本\n",
    "num_samples_to_plot = 3\n",
    "coords = data['coords']\n",
    "forces = data['forces']\n",
    "energies = data['energies']\n",
    "\n",
    "# 计算整体的力大小范围，用于统一颜色映射\n",
    "all_force_mags = np.linalg.norm(forces[:, :, :2], axis=2)\n",
    "vmin, vmax = all_force_mags.min(), all_force_mags.max()\n",
    "norm = plt.Normalize(vmin=vmin, vmax=vmax)\n",
    "cmap = plt.cm.Reds\n",
    "\n",
    "# 创建3个子图并排\n",
    "fig, axes = plt.subplots(1, num_samples_to_plot, figsize=(15, 5), constrained_layout=True)\n",
    "\n",
    "for i, ax in enumerate(axes):\n",
    "    xy_coords = coords[i][:, :2]\n",
    "    force_xy = forces[i][:, :2]\n",
    "    force_mags = np.linalg.norm(force_xy, axis=1)\n",
    "    colors = cmap(norm(force_mags))\n",
    "\n",
    "    # 原子点\n",
    "    ax.scatter(xy_coords[:, 0], xy_coords[:, 1], s=100, c='skyblue', edgecolors='k', label='Atoms')\n",
    "\n",
    "    # 力箭头（带颜色）\n",
    "    scale = 0.01\n",
    "    for j in range(xy_coords.shape[0]):\n",
    "        ax.arrow(xy_coords[j, 0], xy_coords[j, 1],\n",
    "                 force_xy[j, 0] * scale, force_xy[j, 1] * scale,\n",
    "                 color=colors[j], width=0.004, head_width=0.05, alpha=0.8)\n",
    "\n",
    "    # 原子编号\n",
    "    for j, (x, y) in enumerate(xy_coords):\n",
    "        ax.text(x + 0.02, y + 0.02, str(j), fontsize=8)\n",
    "\n",
    "    ax.set_aspect('equal')\n",
    "    ax.set_title(f\"Sample {i}\\nEnergy: {energies[i]:.2f}\")\n",
    "    ax.set_xlabel(\"X\")\n",
    "    ax.set_ylabel(\"Y\")\n",
    "\n",
    "# 添加颜色条（力大小）\n",
    "cbar = fig.colorbar(plt.cm.ScalarMappable(norm=norm, cmap=cmap),\n",
    "                    ax=axes, orientation='vertical', fraction=0.02, pad=0.04)\n",
    "cbar.set_label(\"Force Magnitude (a.u.)\")\n",
    "\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "mindc_py39",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.24"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
